# -*- shell-script -*-

_log_msg()
{
	if [ "$quiet" = "y" ]; then return; fi
	printf "$@"
}

log_success_msg()
{
	_log_msg "Success: $@\n"
}

log_failure_msg()
{
	_log_msg "Failure: $@\n"
}

log_warning_msg()
{
	_log_msg "Warning: $@\n"
}

log_begin_msg()
{
	_log_msg "Begin: $@ ... "
}

log_end_msg()
{
	_log_msg "done.\n"
}

panic()
{
	if command -v chvt >/dev/null 2>&1; then
		chvt 1
	fi

	echo "$@"
	# Disallow console access
	if [ -n "${panic}" ]; then
		echo "Rebooting automatically due to panic= boot argument"
		sleep ${panic}
		reboot
		exit  # in case reboot fails, force kernel panic
	fi
	modprobe -v i8042 || true
	modprobe -v atkbd || true
	modprobe -v ehci-pci || true
	modprobe -v ehci-orion || true
	modprobe -v ehci-hcd || true
	modprobe -v uhci-hcd || true
	modprobe -v ohci-hcd || true
	modprobe -v usbhid || true
	REASON="$@" PS1='(initramfs) ' /bin/sh -i </dev/console >/dev/console 2>&1
}

maybe_break()
{
	if [ "${break:-}" = "$1" ]; then
		panic "Spawning shell within the initramfs"
	fi
}

render()
{
	eval "echo -n \${$@}"
}

set_initlist()
{
	unset initlist
	for si_x in ${initdir}/*; do
		# skip empty dirs without warning
		[ "${si_x}" = "${initdir}/*" ] && return

		# only allow variable name chars
		case ${si_x#${initdir}/} in
		*[![:alnum:]\._-]*)
			[ "${verbose}" = "y" ] \
			&& echo "$si_x ignored: not alphanumeric or '_' file" >&2
			continue
			;;
		esac

		# skip non executable scripts
		if [ ! -x ${si_x} ]; then
			[ "${verbose}" = "y" ] \
			&& echo "$si_x ignored: not executable" >&2
			continue
		fi

		# skip directories
		if [ -d ${si_x} ]; then
			[ "${verbose}" = "y" ] \
			&& echo "$si_x ignored: a directory" >&2
			continue
		fi

		# skip bad syntax
		if ! sh -n ${si_x} ; then
			[ "${verbose}" = "y" ] \
			&& echo "$si_x ignored: bad syntax" >&2
			continue
		fi

		initlist="${initlist:-} ${si_x#${initdir}/}"
	done
}

reduce_satisfied()
{
	deplist="$(render array_${1})"
	unset tmpdeplist
	for rs_y in ${deplist}; do
		# only allow variable name chars
		case ${rs_y} in
		*[![:alnum:]\._-]*)
			continue
			;;
		esac
		# skip non executable scripts
		[ ! -x ${initdir}/${rs_y} ] && continue
		# skip directories
		[ -d ${initdir}/${rs_y} ] && continue
		# skip bad syntax
		sh -n ${initdir}/${rs_y} || continue

		tmpdeplist="${tmpdeplist} ${rs_y}"
	done
	deplist=${tmpdeplist}
	for rs_x in ${runlist}; do
		pop_list_item ${rs_x} ${deplist}
		deplist=${tmppop}
	done
	eval array_${1}=\"${deplist}\"
}

get_prereqs()
{
	set_initlist
	for gp_x in ${initlist}; do
		tmp=$(${initdir}/${gp_x} prereqs)
		eval array_${gp_x}=\"${tmp}\"
	done
}

count_unsatisfied()
{
	set -- ${@}
	return ${#}
}

# Removes $1 from initlist
pop_list_item()
{
	item=${1}
	shift
	set -- ${@}
	unset tmppop
	# Iterate
	for pop in ${@}; do
		if [ ${pop} = ${item} ]; then
			continue
		fi
		tmppop="${tmppop} ${pop}"
	done

}

# This function generates the runlist, so we clear it first.
reduce_prereqs()
{
	unset runlist
	set -- ${initlist}
	i=$#
	# Loop until there's no more in the queue to loop through
	while [ ${i} -ne 0 ]; do
		oldi=${i}
		for rp_x in ${initlist}; do
			reduce_satisfied ${rp_x}
			count_unsatisfied $(render array_${rp_x})
			cnt=${?}
			if [ ${cnt} -eq 0 ]; then
				runlist="${runlist} ${rp_x}"
				pop_list_item ${rp_x} ${initlist}
				initlist=${tmppop}
				i=$((${i} - 1))
			fi
		done
		if [ ${i} -eq ${oldi} ]; then
			panic "PANIC: Circular dependancy.  Exiting."
		fi
	done
}

get_prereq_pairs()
{
	set_initlist
	for gp_x in ${initlist:-}; do
		echo ${gp_x} ${gp_x}
		prereqs=$(${initdir}/${gp_x} prereqs)
		for prereq in ${prereqs}; do
			echo ${prereq} ${gp_x}
		done
	done
}

call_scripts()
{
	set -e
	for cs_x in ${runlist}; do
		[ -f ${initdir}/${cs_x} ] || continue
		# mkinitramfs verbose output
		if [ "${verbose}" = "y" ]; then
			echo "Calling hook ${cs_x}"
		fi
		${initdir}/${cs_x} && ec=$? || ec=$?
		# allow hooks to abort build:
		if [ "$ec" -ne 0 ]; then
			echo "E: ${initdir}/${cs_x} failed with return $ec."
			# only errexit on mkinitramfs
			[ -n "${version}" ] && exit $ec
		fi
		# allow boot scripts to modify exported boot parameters
		if [ -e /conf/param.conf ]; then
			. /conf/param.conf
		fi
	done
	set +e
}

run_scripts()
{
	initdir=${1}
	[ ! -d ${initdir} ] && return

	if [ -f ${initdir}/ORDER ]; then
		. ${initdir}/ORDER
	elif command -v tsort >/dev/null 2>&1; then
		runlist=$(get_prereq_pairs | tsort)
		call_scripts ${2:-}
	else
		get_prereqs
		reduce_prereqs
		call_scripts
	fi
}

# Load custom modules first
load_modules()
{
	if [ -e /conf/modules ]; then
		cat /conf/modules | while read m; do
			# Skip empty lines
			if [ -z "$m" ];  then
				continue
			fi
			# Skip comments - d?ash removes whitespace prefix
			com=$(printf "%.1s" "${m}")
			if [ "$com" = "#" ]; then
				continue
			fi
			modprobe $m
		done
	fi
}

# lilo compatibility
parse_numeric() {
	case $1 in
	"")
		return
		;;
	/*)
		return
		;;
	[0-9]*:[0-9]*)
		minor=$(( ${1#*:} ))
		major=$(( ${1%:*} ))
		;;
	[A-Fa-f0-9]*)
		value=$(( 0x${1} ))
		minor=$(( ${value} % 256 ))
		major=$(( ${value} / 256 ))
		;;
	*)
		return
		;;
	esac

	if command -v udevd >/dev/null 2>&1; then
		ROOT=/dev/block/${major}:${minor}
	else
		mknod -m 600 /dev/root b ${major} ${minor}
		ROOT=/dev/root
	fi
}

# Parameter: device node to check
# Echos fstype to stdout
# Return value: indicates if an fs could be recognized
get_fstype ()
{
	local FS FSTYPE FSSIZE RET
	FS="${1}"

	# blkid has a more complete list of file systems,
	# but fstype is more robust
	FSTYPE="unknown"
	eval $(fstype "${FS}" 2> /dev/null)
	if [ "$FSTYPE" = "unknown" ] &&  command -v blkid >/dev/null 2>&1 ; then
		FSTYPE=$(blkid -o value -s TYPE "${FS}")
	elif [ "$FSTYPE" = "unknown" ] && [ -x /lib/udev/vol_id ]; then
		FSTYPE=$(/lib/udev/vol_id -t "${FS}" 2> /dev/null)
	fi
	RET=$?

	if [ -z "${FSTYPE}" ]; then
		FSTYPE="unknown"
	fi

	echo "${FSTYPE}"
	return ${RET}
}

configure_networking()
{
	if [ -n "${BOOTIF}" ]; then
		# pxelinux sets BOOTIF to a value based on the mac address of the
		# network card used to PXE boot, so use this value for DEVICE rather
		# than a hard-coded device name from initramfs.conf. this facilitates
		# network booting when machines may have multiple network cards.
		# pxelinux sets BOOTIF to 01-$mac_address

		# strip off the leading "01-", which isn't part of the mac
		# address
		temp_mac=${BOOTIF#*-}

		# convert to typical mac address format by replacing "-" with ":"
		bootif_mac=""
		IFS='-'
		for x in $temp_mac ; do
			if [ -z "$bootif_mac" ]; then
				bootif_mac="$x"
			else
				bootif_mac="$bootif_mac:$x"
			fi
		done
		unset IFS

		# look for devices with matching mac address, and set DEVICE to
		# appropriate value if match is found.
		for device in /sys/class/net/* ; do
			if [ -f "$device/address" ]; then
				current_mac=$(cat "$device/address")
				if [ "$bootif_mac" = "$current_mac" ]; then
					DEVICE=${device##*/}
					break
				fi
			fi
		done
	fi

	# networking already configured thus bail out
	[ -n "${DEVICE}" ] && [ -e /run/net-"${DEVICE}".conf ] && return 0

	wait_for_udev 10

	# support ip options see linux sources
	# Documentation/filesystems/nfs/nfsroot.txt
	# Documentation/frv/booting.txt

	for ROUNDTTT in 2 3 4 6 9 16 25 36 64 100; do

		# The NIC is to be configured if this file does not exist.
		# Ip-Config tries to create this file and when it succeds
		# creating the file, ipconfig is not run again.
		for x in /run/net-"${DEVICE}".conf /run/net-*.conf ; do
			[ -e "$x" ] && break 2
		done

		case ${IP} in
		none|off)
			# Do nothing
			;;
		""|on|any)
			# Bring up device
			ipconfig -t ${ROUNDTTT} "${DEVICE}"
			;;
		dhcp|bootp|rarp|both)
			ipconfig -t ${ROUNDTTT} -c ${IP} -d "${DEVICE}"
			;;
		*)
			ipconfig -t ${ROUNDTTT} -d $IP

			# grab device entry from ip option
			NEW_DEVICE=${IP#*:*:*:*:*:*}
			if [ "${NEW_DEVICE}" != "${IP}" ]; then
				NEW_DEVICE=${NEW_DEVICE%%:*}
			else
				# wrong parse, possibly only a partial string
				NEW_DEVICE=
			fi
			if [ -n "${NEW_DEVICE}" ]; then
				DEVICE="${NEW_DEVICE}"
			fi
			;;
		esac
	done

	# source ipconfig output
	if [ -n "${DEVICE}" ]; then
		# source specific bootdevice
		. /run/net-${DEVICE}.conf
	else
		# source any interface...
		# ipconfig should have quit after first response
		. /run/net-*.conf
	fi
}

# Wait for queued kernel/udev events
wait_for_udev()
{
	command -v udevadm >/dev/null 2>&1 || return 0
	udevadm settle ${1:+--timeout=$1}
}

# Find a specific fstab entry
# $1=mountpoint
# $2=fstype (optional)
# returns 0 on success, 1 on failure (not found or no fstab)
read_fstab_entry() {
	# Not found by default.
	found=1

	for file in ${rootmnt}/etc/fstab; do
		if [ -f "$file" ]; then
			while read MNT_FSNAME MNT_DIR MNT_TYPE MNT_OPTS MNT_FREQ MNT_PASS MNT_JUNK; do
				case "$MNT_FSNAME" in
				  ""|\#*)
					continue;
					;;
				esac
				if [ "$MNT_DIR" = "$1" ]; then
					if [ -n "$2" ]; then
						[ "$MNT_TYPE" = "$2" ] || continue;
					fi
					found=0
					break 2
				fi
			done < "$file"
		fi
	done

	return $found
}

# Resolve device node from a name.  This expands any LABEL or UUID.
# $1=name
# Resolved name is echoed.
resolve_device() {
	DEV="$1"

	case $DEV in
	LABEL=*)
		DEV="${DEV#LABEL=}"

		# support any / in LABEL= path (escape to \x2f)
		case "${DEV}" in
		*/*)
		if command -v sed >/dev/null 2>&1; then
			DEV="$(echo ${DEV} | sed 's,/,\\x2f,g')"
		else
			if [ "${DEV}" != "${DEV#/}" ]; then
				DEV="\x2f${DEV#/}"
			fi
			if [ "${DEV}" != "${DEV%/}" ]; then
				DEV="${DEV%/}\x2f"
			fi
			IFS='/'
			newroot=
			for s in $DEV; do
				newroot="${newroot:+${newroot}\\x2f}${s}"
			done
			unset IFS
			DEV="${newroot}"
		fi
		esac
		DEV="/dev/disk/by-label/${DEV}"
		;;
	UUID=*)
		DEV="/dev/disk/by-uuid/${DEV#UUID=}"
		;;
	esac
	# Only canonicalise if a valid file, in case $DEV isn't a filename
	[ -e "$DEV" ] && DEV=$(readlink -f "$DEV")
	echo "$DEV"
}

# Check a file system.
# $1=device
# $2=mountpoint (for diagnostics only)
checkfs()
{
	DEV="$1"
	NAME="$2"
	if [ "$NAME" = "/" ] ; then
		NAME="root"
	fi
	FSCK_LOGFILE=/run/initramfs/fsck

	TYPE=$(get_fstype "$1")

	FSCKCODE=0
	if [ "$fastboot" = "y" ] ; then
		log_warning_msg "Fast boot enabled, so skipping $NAME file system check."
		return
	fi

	if [ "$forcefsck" = "y" ]
	then
		force="-f"
	else
		force=""
	fi

	if [ "$fsckfix" = yes ]
	then
		fix="-y"
	else
		fix="-a"
	fi

	# spinner="-C" -- only if on an interactive terminal
	spinner=""

	if [ "$VERBOSE" = no ]
	then
		log_begin_msg "Will now check $NAME file system"
		logsave -a -s $FSCK_LOGFILE fsck $spinner $force $fix -V -t $TYPE $DEV
		FSCKCODE=$?
		log_end_msg
	else
		log_begin_msg "Checking $NAME file system"
		logsave -a -s $FSCK_LOGFILE fsck $spinner $force $fix -t $TYPE $DEV
		FSCKCODE=$?
		log_end_msg
	fi

	#
	# If there was a failure, drop into a shell.
	#
	# NOTE: "failure" is defined as exiting with a return code of
	# 4 or larger. A return code of 1 indicates that file system
	# errors were corrected but that the boot may proceed. A return
	# code of 2 or 3 indicates that the system should immediately reboot.
	#
	if [ "$FSCKCODE" -eq 32 ]
	then
		log_warning_msg "File system check was interrupted by user"
	elif [ "$FSCKCODE" -gt 3 ]
	then
		# Surprise! Re-directing from a HERE document (as in "cat << EOF")
		# does not work because the fs is currently read-only.
		log_failure_msg "An automatic file system check (fsck) of the $NAME filesystem failed.
A manual fsck must be performed, then the system restarted.
The fsck should be performed in maintenance mode with the
$NAME filesystem mounted in read-only mode."
		log_warning_msg "The $NAME filesystem is currently mounted in read-only mode.
A maintenance shell will now be started.
After performing system maintenance, press CONTROL-D
to terminate the maintenance shell and restart the system."
		# Start a single user shell on the console
		if ! sulogin $CONSOLE
		then
			log_failure_msg "Attempt to start maintenance shell failed.
Will restart in 5 seconds."
			sleep 5
		fi
		if [ "${verbose}" = "y" ] ; then
			log_begin_msg "Will now restart"
		fi
		reboot
	elif [ "$FSCKCODE" -gt 1 ]
	then
		log_failure_msg "The file system check corrected errors on the $NAME partition
but requested that the system be restarted."
		log_warning_msg "The system will be restarted in 5 seconds."
		sleep 5
		if [ "${verbose}" = "y" ] ; then
			log_begin_msg "Will now restart"
		fi
		reboot
	fi
}

# Mount a file system.  We parse the information from the fstab.  This
# should be overridden by any boot script which can mount arbitrary
# filesystems such as /usr.  This default implementation delegates to
# local or nfs based upon the filesystem type.
# $1=mountpoint mount location
mountfs()
{
	type=local
	read_fstab_entry "$1"
	if [ "${MNT_TYPE}" = "nfs" ] || [ "${MNT_TYPE}" = "nfs4" ]; then
		type=nfs
	fi

	${type}_mount_fs "$1"
}

# Mount the root file system.  It should be overridden by all
# boot scripts.
mountroot()
{
	:
}

# Run /scripts/${boot}-top.  This should be overridden by all boot
# scripts.
mount_top()
{
	:
}

# Run /scripts/${boot}-premount.  This should be overridden by all boot
# scripts.
mount_premount()
{
	:
}

# Run /scripts/${boot}-bottom.  This should be overridden by all boot
# scripts.
mount_bottom()
{
	:
}