#!/bin/sh

# this is the init script version
VERSION=@VERSION@
SINGLEMODE=no
sysroot=/sysroot

/bin/busybox mkdir -p /usr/bin /usr/sbin /proc /sys /dev $sysroot \
	/media/cdrom /media/floppy /media/usb /tmp
/bin/busybox --install -s

# basic environment
export PATH=/usr/bin:/bin:/usr/sbin:/sbin

# needed devs
[ -c /dev/null ] || mknod -m 666 /dev/null c 1 3

# basic mounts
mount -t proc -o noexec,nosuid,nodev proc /proc
mount -t sysfs -o noexec,nosuid,nodev sysfs /sys

# some helpers
ebegin() {
	last_emsg="$*"
	[ -n "$KOPT_quiet" ] && return 0
	echo -n " * $last_emsg: "
}
eend() {
	local msg
	if [ "$1" = 0 ] || [ $# -lt 1 ] ; then
		[ -n "$KOPT_quiet" ] && return 0
		echo "ok."
	else
		shift
		if [ "$KOPT_quiet" = "yes" ]; then
			echo -n "$last_emsg "
		fi
		echo "failed. $*"
		echo "initramfs emergency recovery shell launched. Type 'exit' to continue boot"
		/bin/busybox sh
	fi
}

scan_drivers() {
	if [ "$KOPT_autodetect" != no ] ; then
		find /sys -name modalias | xargs sort -u | xargs modprobe -a 2> /dev/null
	fi
}

find_ovl() {
	local mnt="$1"
	local ovl
	local lines

	# look for apkovl's on mounted media
	ovl=$( ls -1 "$mnt"/*.apkovl.tar.gz* 2>/dev/null ) || return 1
	lines=$(echo "$ovl" | wc -l)

	if [ $lines -gt 1 ] ; then
		echo "ERROR: More than one apkovl file was found on $(basename $mnt). None will be read." >&2
		return 1
	fi
	echo "$ovl"
}

retry_mount() {
	# usb might need some time to settle so we retry a few times
	for i in $(seq 0 9); do
		mount $@ 2>/tmp/mount-error && return 0
		sleep 1
	done
	return 1
}

unpack_apkovl() {
	local ovl="$1"
	local dest="$2"
	local suffix=${ovl##*.}
	local i
	ovlfiles=/tmp/ovlfiles
	if [ "$suffix" = "gz" ]; then
		tar -C "$dest" -zxvf "$ovl" > $ovlfiles
		return $?
	fi

	# we need openssl. let apk handle deps
	find_boot_repositories > /tmp/repositories
	apk add --quiet --initdb --repositories-file /tmp/repositories openssl\
		|| return 1

	if ! openssl list-cipher-commands | grep "^$suffix$" > /dev/null; then
		errstr="Cipher $suffix is not supported"
		return 1
	fi
	local count=0
	# beep
	echo -e "\007"
	while [ $count -lt 3 ]; do
		openssl enc -d -$suffix -in "$ovl" | tar --numeric-owner \
			-C "$dest" -zxv >$ovlfiles 2>/dev/null && return 0
		count=$(( $count + 1 ))
	done
	ovlfiles=
	return 1
}

# find mount dir for given device in an fstab
# returns global MNTOPTS
find_mnt() {
	local search_dev="$1" fstab="$2"
	MNTOPTS=
	[ -r "$fstab" ] || return 1
	local dev mnt fs chk
	case "$search_dev" in
		UUID=*|LABEL=*|/dev/*);;
		*) search_dev=/dev/$search_dev;;
	esac
	local search_real_dev=$(resolve_dev $search_dev)
	while read dev mnt fs MNTOPTS chk; do
		local real_dev=$(resolve_dev $dev)
		local i j
		for i in "$search_dev" "$search_real_dev"; do
			[ -z "$i" ] && continue
			for j in "$dev" "$real_dev"; do
				[ -z "$j" ] && continue
				if [ "$i" = "$j" ]; then
					echo "$mnt"
					return
				fi
			done
		done
	done < $fstab
	MNTOPTS=
}

# Wait for usb to settle
wait_usb() {
	if [ -n "$USB_DONE" ] || ! dmesg | grep '^usb-storage: waiting' >/dev/null; then
		return 0
	fi
	ebegin "Waiting for USB device to settle"
	while ! dmesg | grep 'usb-storage: device scan complete' >/dev/null; do
		sleep 1
	done
	USB_DONE=yes
	eend 0
}

#  add a boot service to $sysroot
rc_add() {
	mkdir -p $sysroot/etc/runlevels/$2
	ln -sf /etc/init.d/$1 $sysroot/etc/runlevels/$2/$1
}

# we have issues with some slow usb 1 hosts so we add 1 second delay
# with possibility to increase delay at boot prompt with usbdelay=<sec>
find_ovl_dev() {
	local n i
	# look for apkovl
	for n in $(seq 0 ${KOPT_usbdelay:-1}); do
		# wait for usb to settle if needed
		wait_usb
		for i in usb floppy cdrom; do
			mount -o ro /media/$i 2>/dev/null || continue
			ovl=$(find_ovl /media/$i)
			if [ -f "$ovl" ]; then
				ovl_unmount="$ovl_unmount /media/$i"
				return
			fi
			umount /media/$i 2>/dev/null
		done
		sleep 1
	done
}

setup_inittab_console(){
	while [ $# -gt 0 ]; do
		local tty=${1%,*}
		local speed=${1#*,}
		local line=
		local term=
		case "$tty" in
			ttyS*)
				[ "$speed" = "$1" ] && speed=9600
				term=vt100
				line=-L
				;;
			*)
				[ "$speed" = "$1" ] && speed=38400
				;;
		esac
		shift

                # skip "current console" from beign added to inittab
		[ "$tty" = "tty0" ] && continue

		# do nothing if inittab already have the tty set up
		grep -q "^$tty:" $sysroot/etc/inittab && continue
		echo "# enable login on alternative console" >> $sysroot/etc/inittab
		echo "$tty::respawn:/sbin/getty $line $speed $tty $term" \
			>> $sysroot/etc/inittab
	done
}

start_raid() {
	local n= i=
	case "$KOPT_root" in
		/dev/md*) n=${KOPT_root#/dev/md} ;;
	esac
	case "$KOPT_autoraid" in
		[0-9]*) n="$n $(echo $KOPT_autoraid | tr ',' ' ')" ;;
	esac
	# if kernel can autostart the raid he will
	for i in $n; do
		mknod /dev/md$i b 9 $i
		raidautorun /dev/md$i
	done
	# kernel cannot autostart newer versions of mdadm metadata
	# so we also check if mdadm binary is there
	if [ -x /sbin/mdadm ]; then
		mdadm --assemble --scan
	fi
}

# start cryptsetup if exists
start_cryptsetup() {
	[ -x /sbin/cryptsetup ] || return
	modprobe dm-crypt
	if [ -n "$KOPT_cryptroot" ]; then
		modprobe dm-crypt
		cryptsetup luksOpen "$KOPT_cryptroot" "$KOPT_cryptdm"
	fi
}

# start lvm if exists
start_lvm() {
	[ -x /sbin/lvm ] || return
	modprobe dm-mod
	lvm vgscan --mknodes --ignorelockingfailure >/dev/null 2>&1 &&\
		lvm vgchange --ignorelockingfailure -a y >/dev/null 2>&1
}

# resolve an uuid or symlink to the real device
resolve_dev() {
	case "$1" in
	UUID=*|LABEL=*) findfs "$1";;
	*) readlink -f "$1";;
	esac
}

# relocate ALPINE_MNT according given fstab
relocate_alpine_mnt() {
	local fstab="$1"
	local mnt=$(find_mnt $ALPINE_DEV $fstab)
	if [ -n "$mnt" ] && [ "$ALPINE_MNT" != "$mnt" ]; then
		mkdir -p "$mnt"
		mount -o move $ALPINE_MNT $mnt
		ALPINE_MNT=$mnt
	fi
}

# detect filesystem type on given device/UUID
find_fs_type() {
	local dev=$(findfs $1)
	local i=
	for i in $(blkid $dev); do
		case $i in
		TYPE=*) eval "$i"
			echo $TYPE
			return
			;;
		esac
	done
}

# find the dirs under ALPINE_MNT that are boot repositories
find_boot_repositories() {
	find $ALPINE_MNT -name .boot_repository -type f -maxdepth 3 \
		| sed 's:/.boot_repository$::'
}

# gotta start from somewhere :)
echo "Alpine Init $VERSION"

# read the kernel options. We use eval set so we can handle things like
# acpi_osi="!Windows 2006"
eval set -- `cat /proc/cmdline`

myopts="alpine_dev autodetect autoraid chart cryptroot cryptdm debug_init
	dma init_args keep_apk_new modules ovl_dev pkgs quiet root_size root
	usbdelay"

for opt; do
	case "$opt" in
	s|single|1)
		SINGLEMODE=yes
		continue
		;;
	console=*)
		CONSOLE="$CONSOLE ${opt#console=}"
		continue
		;;
	esac

	for i in $myopts; do
		case "$opt" in
		$i=*)	eval "KOPT_${i}='${opt#*=}'";;
		$i)	eval "KOPT_${i}=yes";;
		no$i)	eval "KOPT_${i}=no";;
		esac
	done
done

# enable debugging if requested
[ -n "$KOPT_debug_init" ] && set -x

# pick first keymap if found
for map in /etc/keymap/*; do
	if [ -f "$map" ]; then
		ebegin "Setting keymap ${map##*/}"
		zcat "$map" | loadkmap
		eend
		break
	fi
done

# start bootcharting if wanted
if [ "$KOPT_chart" = yes ]; then
	ebegin "Starting bootchart logging"
	/sbin/bootchartd start-initfs "$sysroot"
	eend 0
fi

# dma can be problematic
if [ "$KOPT_dma" = no ]; then
	modprobe libata dma=0
fi

ALPINE_DEV=${KOPT_alpine_dev%%:*}
ALPINE_DEV_FS=${KOPT_alpine_dev##*:}
if [ "$ALPINE_DEV_FS" = "$ALPINE_DEV" ]; then
	unset ALPINE_DEV_FS
fi
if [ -n "$KOPT_ovl_dev" ] ; then
	OVL_DEV=${KOPT_ovl_dev%%:*}
	OVL_DEV_FS=${KOPT_ovl_dev##*:}
	if [ "$OVL_DEV_FS" = "$OVL_DEV" ]; then
		unset OVL_DEV_FS
	fi
fi

case "$ALPINE_DEV" in
	UUID=*|LABEL=*) ;;
	*) ALPINE_DEV=/dev/$ALPINE_DEV ;;
esac

# look for standard mountpoint locations
ALPINE_MNT=$(find_mnt $ALPINE_DEV /etc/fstab)
[ -z "$ALPINE_MNT" ] && ALPINE_MNT=/media/${ALPINE_DEV##*/}

# hide kernel messages
[ "$KOPT_quiet" = yes ] && dmesg -n 1

# setup /dev
ebegin "Starting mdev"
mount -t tmpfs -o exec,nosuid,mode=0755,size=1M mdev /dev
echo "/sbin/mdev" > /proc/sys/kernel/hotplug
mdev -s
RC=$?
[ -d /dev/pts ] || mkdir -m 755 /dev/pts
[ -c /dev/ptmx ] || mknod -m 666 /dev/ptmx c 5 2
# make sure /dev/null is setup correctly
[ -f /dev/null ] && rm -f /dev/null
[ -c /dev/null ] || mknod -m 666 /dev/null c 1 3
mount -t devpts -o gid=5,mode=0620,noexec,nosuid devpts /dev/pts
[ -d /dev/shm ] || mkdir /dev/shm
mount -t tmpfs -o nodev,nosuid,noexec shm /dev/shm
eend $RC

# load available drivers to get access to modloop media
ebegin "Loading boot drivers"

modprobe -a $(echo "$KOPT_modules" | tr ',' ' ' ) loop squashfs 2> /dev/null
if [ -f /etc/modules ] ; then
	sed 's/\#.*//g' < /etc/modules |
	while read module args; do
		modprobe -q $module $args
	done
fi
scan_drivers
scan_drivers
eend 0

ebegin "Setting up framebuffer console"
if [ -d /lib/modules/`uname -r`/kernel/drivers/gpu ]; then
	modprobe -q fbcon &>/dev/null
fi
eend 0

# check if root=... was set
if [ -n "$KOPT_root" ]; then
	if [ "$SINGLEMODE" = "yes" ]; then
		echo "Entering single mode. Type 'exit' to continue booting."
		sh
	fi
	# let usb settle in case we boot from usb disks
	[ -n "$KOPT_usbdelay" ] && sleep "$KOPT_usbdelay"
	wait_usb
	start_raid
	start_cryptsetup
	start_lvm
	ebegin "Mounting root"
	retry_mount -o ro $KOPT_root $sysroot 2>/dev/null
	eend $?
	cat /proc/mounts | while read DEV DIR TYPE OPTS ; do
		if [ "$DIR" != "/" -a "$DIR" != "$sysroot" -a -d "$DIR" ]; then
			mkdir -p $sysroot/$DIR
			mount -o move $DIR $sysroot/$DIR
		fi
	done
	sync
	exec /bin/busybox switch_root $sysroot $chart_init /sbin/init $KOPT_init_args
	echo "initramfs emergency recovery shell launched"
	exec /bin/busybox sh
fi

# we only want to wait for usb if really needed at this point
if [ -z "${ALPINE_DEV##*usb*}" ]; then
	wait_usb
fi

# incase we have alpine_dev on raid device...
start_raid
start_cryptsetup
start_lvm

# locate boot media and mount it
ebegin "Mounting boot media"
mkdir -p $ALPINE_MNT

# try detect the filesystem
if [ -z "$ALPINE_DEV_FS" ]; then
	ALPINE_DEV_FS=$(find_fs_type $ALPINE_DEV)
fi

if [ -n "$ALPINE_DEV_FS" ]; then
	mount_opts="-t $ALPINE_DEV_FS"
fi

retry_mount -o ro $mount_opts $ALPINE_DEV $ALPINE_MNT >/dev/null 2>&1
eend $?

# early console?
if [ "$SINGLEMODE" = "yes" ]; then
	echo "Entering single mode. Type 'exit' to continue booting."
	sh
fi

# mount tmpfs sysroot
root_opts="-o mode=0755"
if [ -n "$KOPT_root_size" ]; then
	root_opts="$root_opts,size=$KOPT_root_size"
fi
mount -t tmpfs $root_opts tmpfs $sysroot

if [ -n "$OVL_DEV" ]; then
	mkdir -p /media/$OVL_DEV
	unset mount_opts
	if [ -n "$OVL_DEV_FS" ]; then
		mount_opts="-t $OVL_DEV_FS"
	fi
	
	retry_mount -o ro $mount_opts /dev/$OVL_DEV /media/$OVL_DEV \
		>/dev/null 2>&1
	ovl=$(find_ovl /media/$OVL_DEV)
else
	find_ovl_dev
fi
if ! [ -f "$ovl" ]; then
	ovl=$(find_ovl $ALPINE_MNT)
fi

# parse pkgs=pkg1,pkg2
if [ -n "$KOPT_pkgs" ]; then
	pkgs=$(echo "$KOPT_pkgs" | tr ',' ' ' )
fi

# load apkovl or set up a minimal system
if [ -f "$ovl" ]; then
	ebegin "Loading user settings from $ovl"
	# create apk db and needed /dev/null and /tmp first
	apk add --root $sysroot --initdb --quiet

	unpack_apkovl "$ovl" $sysroot
	eend $? $errstr || ovlfiles=
	# hack, incase /root/.ssh was included in apkovl
	[ -d "$sysroot/root" ] && chmod 700 "$sysroot/root"
	pkgs="$pkgs $(sed 's/\#.*//' $sysroot/etc/lbu/packages.list 2>/dev/null)"
	pkgs="$pkgs $(cat $sysroot/var/lib/apk/world \
		$sysroot/etc/apk/world 2>/dev/null)"
	# clean up after upgrade
	rm -f $sysroot/etc/lbu/packages.list \
		$sysroot/var/lib/apk/world

	# fix up inittab from pre openrc times (alpine v1.8)
	if [ -f "$sysroot"/etc/inittab ]; then
		sed -i -e 's|:/etc/init.d/rcS|:/sbin/rc sysinit|' \
			-e 's|:/etc/init.d/rcL|:/sbin/rc default|' \
			-e 's|:/etc/init.d/rcK|:/sbin/rc shutdown|' \
			"$sysroot"/etc/inittab
	fi
else
	# add some boot services by default
	rc_add devfs sysinit
	rc_add dmesg sysinit
	rc_add mdev sysinit

	rc_add hwclock boot
	rc_add modules boot
	rc_add sysctl boot
	rc_add hostname boot
	rc_add bootmisc boot
	rc_add syslog boot
	
	rc_add mount-ro shutdown
	rc_add killprocs shutdown
	rc_add savecache shutdown
fi

if [ -f $sysroot/etc/fstab ]; then
	has_fstab=1

	# let user override tmpfs size in fstab in apkovl
	mountopts=$(awk '$2 == "/" && $3 == "tmpfs" { print $4 }' $sysroot/etc/fstab)
	if [ -n "$mountopts" ]; then
		mount -o remount,$mountopts $sysroot
	fi

	# move the ALPINE_MNT if ALPINE_DEV is specified in users fstab
	# this is so a generated /etc/apk/repositories will use correct
	# mount dir
	relocate_alpine_mnt "$sysroot"/etc/fstab
fi

# in case we upgrade we might need those:
rc_add hwdrivers sysinit
rc_add modloop sysinit


# hack so we get openrc
pkgs="$pkgs alpine-base"

# copy keys so apk finds them. apk looks for stuff relative --root
mkdir -p $sysroot/etc/apk/keys/
cp -a /etc/apk/keys $sysroot/etc/apk

# generate apk repositories file. needs to be done after relocation
find_boot_repositories > /tmp/repositories

# generate repo opts for apk
for i in $(cat /tmp/repositories); do
	repo_opt="$repo_opt --repository $i"
done

# install new root
ebegin "Installing packages to root filesystem"
# insert newline unless quiet to fix progress bar
[ -n "$KOPT_quiet" ] || echo ""

if [ "$KOPT_chart" = yes ]; then
	pkgs="$pkgs acct"
fi
apkflags="--initdb --progress --force --no-network"
if [ -n "$KOPT_quiet" ]; then
	apkflags="$apkflags --quiet"
fi

if [ "$KOPT_keep_apk_new" != yes ]; then
	apkflags="$apkflags --clean-protected"
	[ -n "$ovlfiles" ] && apkflags="$apkflags --overlay-from-stdin"
fi

if [ -n "$ovlfiles" ]; then
	apk add --root $sysroot $repo_opt $apkflags $pkgs <$ovlfiles>/dev/null 
else
	apk add --root $sysroot $repo_opt $apkflags $pkgs >/dev/null
fi
eend $?

# unmount ovl mount if needed
if [ -n "$ovl_unmount" ]; then
	umount $ovl_unmount 2>/dev/null
fi

# remount ALPINE_MNT according default fstab from package
if [ -z "$has_fstab" ] && [ -f "$sysroot"/etc/fstab ]; then
	relocate_alpine_mnt "$sysroot"/etc/fstab
fi

# generate repositories if none exists. this needs to be done after relocation
if ! [ -f "$sysroot"/etc/apk/repositories ]; then
	find_boot_repositories > "$sysroot"/etc/apk/repositories
fi

# respect mount options in fstab for ALPINE_MNT (e.g if user wants rw)
if [ -f "$sysroot"/etc/fstab ]; then
	opts=$(awk "\$2 == \"$ALPINE_MNT\" {print \$4}" $sysroot/etc/fstab)
	if [ -n "$opts" ]; then
		mount -o remount,$opts "$ALPINE_MNT"
	fi
fi

# fix inittab if alternative console
setup_inittab_console $CONSOLE

# copy alpine release info
if ! [ -f "$sysroot"/etc/alpine-release ]; then
	cp $ALPINE_MNT/.alpine-release $sysroot/
	ln -sf /.alpine-release $sysroot/etc/alpine-release
fi

# setup bootchart for switch_root
chart_init=""
if [ "$KOPT_chart" = yes ]; then
	/sbin/bootchartd stop-initfs "$sysroot"
	chart_init="/sbin/bootchartd start-rootfs"
fi

if [ ! -x $sysroot/sbin/init ]; then
	echo "/sbin/init not found in new root. Launching emergency recovery shell"
	echo "Type exit to continue boot."
	/bin/busybox sh
fi

# switch over to new root
cat /proc/mounts | while read DEV DIR TYPE OPTS ; do
	if [ "$DIR" != "/" -a "$DIR" != "$sysroot" -a -d "$DIR" ]; then
		mkdir -p $sysroot/$DIR
		mount -o move $DIR $sysroot/$DIR
	fi
done
sync

echo ""
exec /bin/busybox switch_root $sysroot $chart_init /sbin/init $KOPT_init_args

echo "initramfs emergency recovery shell launched"
exec /bin/busybox sh
reboot