initrc

#!${ROOTFS_SHELL}
if [ "${1}" == "debug" ]; then
	shift
	set -x
fi

PATH="${ROOTFS_PATH}"
export ${ROOTFS_NAME}_init="false"
export ${ROOTFS_NAME}_load="false"

#note: mount locations:
#	device:			/.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT}
#	chroot squashfs:	/.${ROOTFS_ROOT_OPT}.shm/lowerdir
#	chroot shmem:		/.${ROOTFS_ROOT_OPT}.shm -> /.${ROOTFS_ROOT_OPT}${_GOVLY}
#	chroot:			/.${ROOTFS_ROOT_OPT}
#	root squashfs:		${_GOVLY}.shm/lowerdir
#	root shmem:		${_GOVLY}.shm -> ${_GOVLY}${_GOVLY}
#	root:			${_GOVLY}

#{CMD} sed -nr -e "s/ \|\| .+$//g" -e "s|^[[:space:]]*[$][{]ROOTFS_NAME[}] ||gp" ./artifacts/files/initrc

marker() {
	echo -en "################################################################################\n"
	return 0
}

${ROOTFS_FUNC}() {
	marker
	echo -en "#\n"
	echo -en "# ${_TITLE}: ${ROOTFS_FUNC} shell\n"
	echo -en "#\n"
	if [ "${1}" != "-" ]; then
		shift
		echo -en "# AN ERROR HAS OCCURRED -- DROPPING TO THE COMMAND LINE\n"
		echo -en "#\n"
	fi
	${ROOTFS_FUNC}_note="false"
	if [ -n "`grep -E "^[^[:space:]]+ /.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT}" /proc/mounts`" ]; then
		echo -en "# device is mounted (/.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT}): "
		sed -r -n "s|^([^[:space:]]+) /.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT}.+$|\1|gp" /proc/mounts
		${ROOTFS_FUNC}_note="true"
	fi
	if [ -n "`grep -E "^overlay /.${ROOTFS_ROOT_OPT} overlay" /proc/mounts`" ]; then
		echo -en "# chroot environment is mounted: /.${ROOTFS_ROOT_OPT}\n"
		${ROOTFS_FUNC}_note="true"
	fi
	if [ -n "`grep -E "^overlay ${_GOVLY} overlay" /proc/mounts`" ]; then
		echo -en "# root filesystem is mounted: ${_GOVLY}\n"
		${ROOTFS_FUNC}_note="true"
	fi
	if ${${ROOTFS_FUNC}_note}; then
		echo -en "#\n"
	fi
	echo -en "# use \"${ROOTFS_NAME} -\" to launch the ${ROOTFS_NAME} selection menu\n"
	echo -en "# use \"${ROOTFS_NAME} =\" to load the ${ROOTFS_NAME} chroot environment\n"
	echo -en "# use \"${ROOTFS_NAME} [...]\" to boot using the specified ${ROOTFS_NAME} values\n"
	echo -en "# use \"un${ROOTFS_NAME}\" to unmount all the ${ROOTFS_NAME} directories\n"
	echo -en "# use \"dotty\" or \"dottys\" to start a psuedo-terminal (login: root / ${_GPASS})\n"
	echo -en "#\n"
	echo -en "# exiting the shell will return control to the \"/initrc\" script\n"
	echo -en "#\n"
	marker
	exec ${ROOTFS_SHELL} -l
	return 1
}

mounts() {
	mounts="${1}"; shift
	do_mnt="${1}"; shift
	if ! ${do_mnt}; then
		lsof | sed -r -n "s|^([0-9]+)[[:space:]]+${mounts}.+$|\1|gp" | sort -u | while read -r file; do
			kill -9 ${file} || return 1
		done
		sed -r -n "s%^.+(${mounts}/(dev|proc|sys)/[^[:space:]]+).+$%\1%gp" /proc/mounts | sort -ru | while read -r file; do
			umount -v ${file} || return 1
		done
		count 1 1
		for mount in \
			${mounts}/dev \
			${mounts}/proc \
			${mounts}/sys \
		; do
			if [ -n "`grep -E " ${mount} " /proc/mounts`" ]; then
				umount -v ${mount} || return 1
			fi
		done
		return 0
	fi
	if [ -z "`grep -E "^none ${mounts}/dev devtmpfs" /proc/mounts`" ]; then
		mkdir -v -p ${mounts}/dev || return 1
		mount -v -t devtmpfs none ${mounts}/dev || return 1
	fi
	if [ -z "`grep -E "^none ${mounts}/proc proc" /proc/mounts`" ]; then
		mkdir -v -p ${mounts}/proc || return 1
		mount -v -t proc none ${mounts}/proc || return 1
	fi
	if [ -z "`grep -E "^none ${mounts}/sys sysfs" /proc/mounts`" ]; then
		mkdir -v -p ${mounts}/sys || return 1
		mount -v -t sysfs none ${mounts}/sys || return 1
	fi
	if [ -z "${mounts}" ]; then
		ln -v -fs /proc/mounts /etc/mtab || return 1
		mdev -s || return 1
#>>>		if [ -d "/proc/sys/kernel" ]; then
#>>>			echo -en "mdev" >/proc/sys/kernel/hotplug
#>>>		fi
	fi
	return 0
}

${ROOTFS_NAME}() {
	mounts="${1}"; shift
	${ROOTFS_NAME}="${1}"; shift
	do_mnt="false"
	to_mem="false"
	do_pak="false"
	if [ "${${ROOTFS_NAME}}" == true ]; then
		do_mnt="true"
	elif [ -f "${${ROOTFS_NAME}}" ]; then
		do_mnt="true"
		[ "${1}" == true ] && to_mem="${1}"; shift
		[ "${1}" == true ] && do_pak="${1}"; shift
	fi
	if ! ${do_mnt}; then
		mounts ${mounts} false || return 1
		if [ -n "`grep -E " ${mounts}/.${ROOTFS_ROOT_OPT} " /proc/mounts`" ]; then
			umount -v ${mounts}/.${ROOTFS_ROOT_OPT} || return 1
		fi
		if [ -n "`grep -E " ${mounts}${_GOVLY} " /proc/mounts`" ]; then
			mount -v -o move ${mounts}${_GOVLY} ${mounts}.shm || return 1
		fi
		for mount in \
			${mounts} \
			${mounts}.shm/lowerdir \
			${mounts}.shm \
		; do
			if [ -n "`grep -E " ${mount} " /proc/mounts`" ]; then
				umount -v ${mount} || return 1
			fi
		done
		return 0
	fi
	if	[ -z "`grep -E "^shm ${mounts}.shm tmpfs" /proc/mounts`" ] &&
		[ -z "`grep -E "^shm ${mounts}${_GOVLY} tmpfs" /proc/mounts`" ]
	then
		mkdir -v -p ${mounts}.shm || return 1
		mount -v -o size=${${ROOTFS_ROOT_OPT}_size} -t tmpfs shm ${mounts}.shm || return 1
		mkdir -v -p ${mounts}.shm/lowerdir || return 1
		mkdir -v -p ${mounts}.shm/upperdir || return 1
		mkdir -v -p ${mounts}.shm/workdir || return 1
	fi
	if [ -f "${${ROOTFS_NAME}}" ]; then
		${ROOTFS_NAME}_shm="${mounts}.shm${ROOTFS_ROOT}"
		if ${to_mem} && (
			[ ! -f ${${ROOTFS_NAME}_shm} ] &&
			[ ! -f ${mounts}${_GOVLY}${ROOTFS_ROOT} ]
		); then
			mkdir -v -p `dirname ${${ROOTFS_NAME}_shm}` || return 1
			rsync -avv --progress --copy-links ${${ROOTFS_NAME}} ${${ROOTFS_NAME}_shm} || return 1
			${ROOTFS_NAME}="${${ROOTFS_NAME}_shm}"
		fi
		if	[ -z "`grep -E "^/dev/loop[0-9] ${mounts}.shm/lowerdir ${ROOTFS_TYPE}" /proc/mounts`" ] &&
			[ -z "`grep -E "^/dev/loop[0-9] ${mounts}${_GOVLY}/lowerdir ${ROOTFS_TYPE}" /proc/mounts`" ]
		then
			mount -v -t ${ROOTFS_TYPE} -o ro,loop ${${ROOTFS_NAME}} ${mounts}.shm/lowerdir || return 1
		fi
		if [ -z "`grep -E "^overlay ${mounts} overlay" /proc/mounts`" ]; then
			mkdir -v -p ${mounts} || return 1
			lowerdir="${mounts}.shm/lowerdir"
			upperdir="${mounts}.shm/upperdir"
			workdir="${mounts}.shm/workdir"
			mount -v -t overlay overlay -o lowerdir=${lowerdir},upperdir=${upperdir},workdir=${workdir},${ROOTFS_OPTS_MNT} ${mounts} || return 1
		fi
		if [ -z "`grep -E "^shm ${mounts}${_GOVLY} tmpfs" /proc/mounts`" ]; then
			mkdir -v -p ${mounts}${_GOVLY} || return 1
			mount -v -o move ${mounts}.shm ${mounts}${_GOVLY} || return 1
		fi
		if ${do_pak} && [ -d ${mounts}/.${_TITLE} ]; then
			make -C ${mounts}/.${_TITLE} O=${mounts} unpack || return 1
		fi
	fi
	return 0
}

select() {
	${ROOTFS_ROOT_OPT}="`sed -r -n "s|^.*${ROOTFS_ROOT_OPT}=([^ ]+).*$|\1|gp" /proc/cmdline`"
	${ROOTFS_ROOT_OPT}_size="`sed -r -n "s|^.*${ROOTFS_ROOT_OPT}_size=([^ ]+).*$|\1|gp" /proc/cmdline`"
	${ROOTFS_ROOT_OPT}_file="`sed -r -n "s|^.*${ROOTFS_ROOT_OPT}_file=([^ ]+).*$|\1|gp" /proc/cmdline`"
	${ROOTFS_ROOT_OPT}_hint="`sed -r -n "s|^.*${ROOTFS_ROOT_OPT}_hint=([^ ]+).*$|\1|gp" /proc/cmdline`"
	select_opt="false"; if [ "${1}" == "-" ]; then select_opt="true"; shift; fi
	chroot_opt="false"; if [ "${1}" == "=" ]; then chroot_opt="true"; shift; fi
	if [ -n "${1}" ]; then
		${ROOTFS_ROOT_OPT}="${1}"; shift
		if [ -n "${1}" ]; then
			${ROOTFS_ROOT_OPT}_file="${1}"; shift
		fi
	elif
		[ -z "${${ROOTFS_ROOT_OPT}}" ] &&
		! ${select_opt} &&
		! ${chroot_opt}
	then
		return 1
	fi
	if [ -z "${${ROOTFS_ROOT_OPT}_file}" ]; then
		${ROOTFS_ROOT_OPT}_file="${ROOTFS_ROOT_SRC}"
	fi
	if ! ${select_opt} && (
		[ -n "`echo "${${ROOTFS_ROOT_OPT}}" | grep -E "^/dev/.+$"`" ] ||
		[ -n "`echo "${${ROOTFS_ROOT_OPT}}" | grep -E "^[0-9]+[.][0-9]+[.][0-9]+[.][0-9]+$"`" ] ||
		${chroot_opt}
	); then
		if	[ -z "`echo "${${ROOTFS_ROOT_OPT}}" | grep -E "^/dev/.+$"`" ] ||
			[ ! -b "${${ROOTFS_ROOT_OPT}}" ] ||
			! mkdir -v -p /.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT} ||
			! mount -v -o ro ${${ROOTFS_ROOT_OPT}} /.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT} ||
			${chroot_opt}
		then
			#note: mounting and unpacking the default image in place
			#note: it is already in memory, and does not need to be copied
			${ROOTFS_NAME} /.${ROOTFS_ROOT_OPT} ${ROOTFS_ROOT} false true || ${ROOTFS_FUNC}
			mounts /.${ROOTFS_ROOT_OPT} true || ${ROOTFS_FUNC}
			if [ ! -d /.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT} ]; then
				mkdir -v -p /.${ROOTFS_ROOT_OPT}/run/openrc || ${ROOTFS_FUNC}
				touch /.${ROOTFS_ROOT_OPT}/run/openrc/softlevel || ${ROOTFS_FUNC}
				chroot /.${ROOTFS_ROOT_OPT} rc-update add udev default || ${ROOTFS_FUNC}
				chroot /.${ROOTFS_ROOT_OPT} rc-update add modules default || ${ROOTFS_FUNC}
				chroot /.${ROOTFS_ROOT_OPT} openrc || ${ROOTFS_FUNC}
				mkdir -v -p /.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT} || ${ROOTFS_FUNC}
			fi
			if	[ -n "`echo "${${ROOTFS_ROOT_OPT}}" | grep -E "^/dev/.+$"`" ] &&
				[ -z "`grep -E "^${${ROOTFS_ROOT_OPT}} /.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT}" /proc/mounts`" ]
			then
				if	! chroot /.${ROOTFS_ROOT_OPT} mount -v -o ro ${${ROOTFS_ROOT_OPT}} /.${ROOTFS_ROOT_OPT} &&
					! ${chroot_opt}
				then
#>>>					${ROOTFS_FUNC}
					select - "${${ROOTFS_ROOT_OPT}}" "${${ROOTFS_ROOT_OPT}_file}" || return 1
					return 0
				fi
			elif	[ -n "`echo "${${ROOTFS_ROOT_OPT}}" | grep -E "^[0-9]+[.][0-9]+[.][0-9]+[.][0-9]+$"`" ] &&
				[ ! -f "${_GOVLY}.shm${ROOTFS_ROOT}" ]
			then
				chroot /.${ROOTFS_ROOT_OPT} rc-update add dhcpcd default || ${ROOTFS_FUNC}
				chroot /.${ROOTFS_ROOT_OPT} openrc || ${ROOTFS_FUNC}
				chroot /.${ROOTFS_ROOT_OPT} rc-service dhcpcd restart || ${ROOTFS_FUNC}
				if ! ${chroot_opt}; then
					count 9 27
				fi
				mkdir -v -p `dirname /.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT}${${ROOTFS_ROOT_OPT}_file}` || ${ROOTFS_FUNC}
				#note: creating the "shm" mount, and using "tftp" to put the image in the right place
				#note: this way the image is only being put into memory once
				${ROOTFS_NAME} ${_GOVLY} true || ${ROOTFS_FUNC}
#>>>				if	! tftp -v ${${ROOTFS_ROOT_OPT}} -c get ${${ROOTFS_ROOT_OPT}_file} ${_GOVLY}.shm${ROOTFS_ROOT} &&
				if	! tftp ${${ROOTFS_ROOT_OPT}} -g -r ${${ROOTFS_ROOT_OPT}_file} -l ${_GOVLY}.shm${ROOTFS_ROOT} &&
					! ${chroot_opt}
				then
#>>>					${ROOTFS_FUNC}
					select - "${${ROOTFS_ROOT_OPT}}" "${${ROOTFS_ROOT_OPT}_file}" || return 1
					return 0
				fi
			fi
			if ${chroot_opt}; then
				marker
				echo -en "#\n"
				echo -en "# ${_TITLE}: ${ROOTFS_NAME} chroot\n"
				echo -en "#\n"
				echo -en "# expected location of ${ROOTFS_NAME} file: /.${ROOTFS_ROOT_OPT}${${ROOTFS_ROOT_OPT}_file}\n"
				echo -en "# exiting the shell will return control to the \"/initrc\" script\n"
				echo -en "#\n"
				marker
				chroot /.${ROOTFS_ROOT_OPT} ${ROOTFS_BASH} || ${ROOTFS_FUNC}
			fi
		fi
		if [ -f "/.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT}${${ROOTFS_ROOT_OPT}_file}" ]; then
			#note: doing this in three steps to manage memory consumption
			#note: having both images in memory, and unpacked, all at once, is very expensive
			${ROOTFS_NAME} ${_GOVLY} /.${ROOTFS_ROOT_OPT}/.${ROOTFS_ROOT_OPT}${${ROOTFS_ROOT_OPT}_file} true false || ${ROOTFS_FUNC}
			${ROOTFS_NAME} /.${ROOTFS_ROOT_OPT} false || ${ROOTFS_FUNC}
			${ROOTFS_NAME} ${_GOVLY} ${_GOVLY}${_GOVLY}${ROOTFS_ROOT} false true || ${ROOTFS_FUNC}
			return 0
		elif [ -f "${_GOVLY}.shm${ROOTFS_ROOT}" ]; then
			#note: the "shm" mount was created earlier, and the image placed in the right place by "tftp"
			#note: all that needs to be done is to mount and unpack it
			${ROOTFS_NAME} ${_GOVLY} ${_GOVLY}.shm${ROOTFS_ROOT} false true || ${ROOTFS_FUNC}
			${ROOTFS_NAME} /.${ROOTFS_ROOT_OPT} false || ${ROOTFS_FUNC}
			return 0
		else
			select - "${${ROOTFS_ROOT_OPT}}" "${${ROOTFS_ROOT_OPT}_file}" || return 1
			return 0
		fi
	else
		marker
		echo -en "#\n"
		echo -en "# ${_TITLE}: ${ROOTFS_NAME} selection\n"
		echo -en "#\n"
		echo -en "# selected source of ${ROOTFS_NAME} file: ${${ROOTFS_ROOT_OPT}}\n"
		echo -en "# expected location of ${ROOTFS_NAME} file: ${${ROOTFS_ROOT_OPT}_file}\n"
		echo -en "# available bootloader hint: ${${ROOTFS_ROOT_OPT}_hint}\n"
		echo -en "#\n"
		echo -en "# the ${ROOTFS_NAME} file was not found using these settings\n"
		echo -en "#\n"
		echo -en "# please enter a new device or partition\n"
		echo -en "# using an ip address will set up dhcp and tftp from that server\n"
		echo -en "# a different file location can be specified after the source\n"
		echo -en "#\n"
		echo -en "# examples:\n"
		echo -en "# /dev/sda1  -or- /dev/sda1  ${ROOTFS_ROOT_SRC}\n"
		echo -en "# 10.0.0.254 -or- 10.0.0.254 ${ROOTFS_ROOT_SRC}\n"
		echo -en "#\n"
		echo -en "# use \"l\" to get a list of available devices and partitions\n"
		echo -en "# use \"g\" to boot the default ${ROOTFS_NAME}\n"
		echo -en "# use \"c\" to enter the chroot environment\n"
		echo -en "# use \"q\" for the ${ROOTFS_FUNC} shell\n"
		echo -en "#\n"
		marker
		echo -en "> "
		read ${ROOTFS_ROOT_OPT}
		if [ "${${ROOTFS_ROOT_OPT}}" == "l" ]; then
			marker
			fdisk -l | grep -E "^(Disk|[[:space:]]*[0-9])"
			marker
			echo -en "#\n"
			echo -en "# the \"c\" chroot environment may be necessary if there were no results\n"
			echo -en "# hit \"enter\" to continue\n"
			echo -en "#\n"
			marker
			read continue
			select - || return 1
			return 0
		elif [ "${${ROOTFS_ROOT_OPT}}" == "g" ]; then
			return 1
		elif [ "${${ROOTFS_ROOT_OPT}}" == "c" ]; then
			select =
			return 0
		elif [ "${${ROOTFS_ROOT_OPT}}" == "q" ]; then
			${ROOTFS_FUNC} -
			return 0
		elif [ -z "${${ROOTFS_ROOT_OPT}}" ]; then
			select - || return 1
			return 0
		else
			select ${${ROOTFS_ROOT_OPT}} || ${ROOTFS_FUNC}
			return 0
		fi
	fi
	${ROOTFS_FUNC}
	return 1
}

count() {
	time="${1}"; shift
	line="${1}"; shift
	wait="`expr ${time}00 / ${line}`"
	if [ "${wait}" -lt "10" ]; then
		wait="0.0${wait}"
	else
		wait="0.${wait}"
	fi
	doit="0"
	while [ "${doit}" -lt "${line}" ]; do
		echo -en ".\n"
		sleep "${wait}"
		doit="`expr ${doit} + 1`"
	done
	return 0
}

if [ "${1}" == "un${ROOTFS_NAME}" ]; then
	shift
	#note: unmounting both the "chroot" and the "overlay"
	#note: doing it in reverse order of usage, to avoid any collisions
	${ROOTFS_NAME} ${_GOVLY} false || ${ROOTFS_FUNC}
	${ROOTFS_NAME} /.${ROOTFS_ROOT_OPT} false || ${ROOTFS_FUNC}
	count 1 1
	mount -l
	${ROOTFS_FUNC} -
else
	if [ "${1}" == "${ROOTFS_NAME}" ]; then
		shift
		count 1 3
	else
		count 3 9
	fi
	mounts "" true || ${ROOTFS_FUNC}
	if ! ${${ROOTFS_NAME}_init} || [ -n "${@}" ]; then
		export ${ROOTFS_NAME}_init="true"
		if select "${@}"; then
			export ${ROOTFS_NAME}_load="true"
		fi
	else
		if select - "${${ROOTFS_ROOT_OPT}}" "${${ROOTFS_ROOT_OPT}_file}"; then
			export ${ROOTFS_NAME}_load="true"
		fi
	fi
	if ! ${${ROOTFS_NAME}_load}; then
		#note: mounting the default image at "overlay"
		#note: the is the most straightforward mount, of all of them
		${ROOTFS_NAME} ${_GOVLY} ${ROOTFS_ROOT} true true || ${ROOTFS_FUNC}
	fi
fi

if ${DOTEST}; then
	marker
	echo -en "# ${_TITLE}: success!\n"
	marker
	${ROOTFS_FUNC} -
fi
kill -SIGQUIT 1

exit 1