#!/bin/sh
# Copyright 2018 Didier Spaier <didier~at~slint~dot~fr>
#
# All rights reserved.
#
# Redistribution and use of this script, with or without modification, is
# permitted provided that the following conditions are met:
#
# 1. Redistributions of this script must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#
#  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
#  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
#  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
#  EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
#  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
#  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
#  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# Last updated on Sunday 17 June 2018 21.46 Paris time.

# TODO:
# add as "super-fallback" /EFI/startup.nsh if absent?
# Internationalize.

# This script provides boot menu entries for all accessible EFI OS
# loaders.

# Features:
# Write an EFI application displaying an menu entry for each EFI boot
# loader located in a device connected to the computer.
# Install the EFI application in a mass storage device, in a specific
# location and optionally as a fall back as /BOOT/EFI/BOOTx64.EFI
# Install the EFI application in an USB stick.
# Make an entry for the EFI application menu in the firmware.
# Allow the user to hide menu entries and edit and change the order of
# their displayed labels.
# When installing in a mass storage device, remove the EFI applications
# previously installed by this script.

# Limitations: this script only handles EFI images accessible at time of
# running it, stored in an ESP with a FAT file system, with a partition
# table labeled either msdos or gpt.
# It can need adaptation to Linux distribution not based on Slackware.
# It can't distinguish with certainty EFI boot loaders from other EFI
# files, hence can display entries for these pother EFI files in the
# boot menu.

# Permanent files written:
# An EFI application in the form of PE32+ executable that gives access
# to EFI boot-loaders, stored in /boot as efimultibootmenux64.efi and
# copied in its installation locations as BOOTx64.EFI, written by
# grub.mkimage
# A configuration file grub.cfg stored alongside and read by BOOTx64.EFI
# in the target ESP, and its md5 chacksum
# A md5 checksum efibootmenu.md5 of BOOTx64.EFI stored alongside it.
# /var/efibootmenu stores one line per boot entry, with as format
# allowing to store customized labels and record hidden ones.
# /var/efibootmenuinstall records the UUID of the ESP where the
# PE+32 image and associated grub.cfg are installed and the path to
# these files inside the ESP
# A NVRAM variable in the firmware to link to the PE32+ executable
# written by this script.
# /etc/efibootmenu/timeout stores the timeout in seconds before starting
# the first boot entry, if set by the user.
# /etc/efibootmenu/usersound stores the choice of a sound (y) or mute
# (n) boot menu if set by the user.

# Purpose of temporary files used:
# TMP: main temporary dir. All other temporary files are in $TMP
# MENU: menu as will be displayed when running the PE32+ executable
# NEWMENU: temporary MENU while reordered
# LINE: a line of $MENU being edited
# ESPLIST: list of EFI System Partitions accessible at time of running
# this script
# ACCESSIBLE: lists the EFI loaders accessible at time of running this
# script will be copied to /var/efibootmenu
# MNT: directory used as mount point for the ESP listed in ESPLIST. We
# assume that if an ESP is already mounted, probably on /boot/efi, it is
# with read and write permissions for root. Also used as mount point for
# the USB stick on which write the PE32+ image and grub.cfg
# BEFORE, AFTER: register the lists of USB sticks resp. before and after
# the user should have plugged in the one on which to write the PE32+
# image
# grub.cfg that will be written in the target ESP
#
# Commands that have been used used to test this script are shipped in:
# coreutils, efibootmgr, file, grep, gptfdisk, grub-2.02, parted,
# util-linux in a Slint or Slackware distribution. A run-time dependency
# to grub could be avoided shipping a pre-built PE32+ image. This will
# be proposed in a further release.

# Initialization
if [ $(id -u) -ne 0 ]; then
	echo "Only root may run this script."
	exit
fi
if [ ! -d /sys/firmware/efi ]; then
	echo "EFI booting is not enabled, game over."
	exit
fi
# The UEFI specification states that an EFI System partition has
# a GUID of C12A7328-F81F-11D2-BA4B-00A0C93EC93B for a GPT layout.
# In case of a DOS layout instead, an ESP should have an OS type of
# 0xEF. lsblk writes these values in the same field PARTTYPE.
ESPPARTTYPE=C12A7328-F81F-11D2-BA4B-00A0C93EC93B
OSTYPE=0xEF
# Ref: https://fr.wikipedia.org/wiki/Note_de_musique
SCALE="26163 29366 32963 34923 39200 44000 49388"
#      do    ré    mi    fa    sol   la    si
HALT="play 240 523 3 392 3 330 3 262 3"
REBOOT="play 240 523 1 392 1 330 1 262 1 330 1 392 1 523 1" 
TMP=$(mktemp -d)
MNT=$TMP/MNT
mkdir -p $MNT
mkdir -p /etc/efibootmenu
ESPLIST=$TMP/ESPLIST

# Main functions:
#
# install_on_system_ESP: makes and install the EFI boot manager on a
# mass storage device permanently attached to the computer.
#
# install_on_USB_stick: wipes out and format an USB stick with an ESP 
# and installs the EFI boot manager there.
#
# install_in_firmware: insert an entry for the boot manager in the
# firmware's boot menu.
#
# edit_the_menu: allow the user to hide or show a menu entry, modify
# the label of a menu entry or change the order of the boot entries

About_EFI3M() {
clear
echo \
"The EFI Multi Boot Menu Maker (EFI3M) allows booting any installed
system for which an EFI boot loader is found on the computer. It comes
handy if you can't boot otherwise some installed system.

Features:
1) Build a boot menu and install it in an EFI system partition of your
   computer, in a specific location and, if not already busy, optionally
   in a fall back location where the firmware should look at priority.
2) Install the boot menu on an USB stick. Then you can boot off the USB
   stick, which in turn will present you with the boot menu allowing to
   boot any of the installed systems. This helps in case for some reason
   the internal boot menu be not displayed.
2) Customize the boot menu: hide a menu entry, edit its displayed label,
   modify the order in which the entries are displayed, set the delay
   before auto boot, mute or sound the menu.
   All modifications will be automatically applied to the internal boot
   menu; to apply them to the USB stick you will need to write again the
   menu on it.

Caveat: the menu built by EFI3M can include entries for EFI files that
are not boot loaders, or not working ones. Just hide them editing it.
"

read -p "Press Enter to continue. " dummy
}

to_lower() {
echo "$1"|tr '[:upper:]' '[:lower:]'
}

frequency() {
	# We won't play a tune for more than 35 entries...
	ENTRYNUM=$1
	if [ $ENTRYNUM -lt 8 ]; then
		OCTAVE=1
	elif [ $ENTRYNUM -lt 15 ]; then
		OCTAVE=2
	elif [ $ENTRYNUM -lt 22 ]; then
		OCTAVE=3
	elif [ $ENTRYNUM -lt 29 ]; then
		OCTAVE=4
	elif [ $ENTRYNUM -lt 36 ]; then
		OCTAVE=5
	else
		echo ""
		return
	fi
	NUMNOTE=$(($ENTRYNUM-(${OCTAVE}-1)*7))
	CENTIHERZ=$(($(echo $SCALE|cut -d" " -f$NUMNOTE)*${OCTAVE}))
	REMAIN=0
	if [ $(($CENTIHERZ % 100)) -gt 49 ]; then
		REMAIN=1
	fi
	FREQUENCY=$((($CENTIHERZ/100)+$REMAIN))
	echo $FREQUENCY
}

playtune() {
	TUNE="play 480 "
	i=1
	while [ $i -le $1 ]; do
		TUNE="$TUNE $(frequency $i) 2"
		i=$((${i}+1))
	done
	echo $TUNE
}	

one_space() {
	echo "$1"|sed "s/ \{1,\}/ /g"
}

set_mountpoint() {
	ESP_NAME=$(one_space "$(lsblk -l -o uuid,name)"|grep $UUID|cut -d" " -f 2)
	MOUNTPOINT=$(one_space "$(df -h)"|grep /dev/$ESP_NAME|cut -d" " -f 6)
	ESP=/dev/$ESP_NAME
	MOUNTED=y
	if [ "$MOUNTPOINT" = "" ]; then
		MOUNTPOINT=$MNT
		mount $ESP $MNT
		MOUNTED=n
	fi 
}

remove_previous_files() {
	if [ ! -f /var/efibootmenuinstall ]; then
		return
	fi
	while read UUID EFIPATH; do
		set_mountpoint
		EFIDIR=$(dirname $EFIPATH)
		if [ ! -d $MOUNTPOINT$EFIDIR ]; then
			# Don't try to cd to a directory that have been removed
			# after previous installation in system ESP
			continue
		fi
		( cd $MOUNTPOINT$EFIDIR
		if [ -f efibootmenu.md5 ]; then
			if md5sum -c --quiet efibootmenu.md5; then
				rm BOOTx64.EFI
				rm efibootmenu.md5
			fi
		fi
		if [ -f efibootgrub.md5 ]; then
			if md5sum -c --quiet efibootgrub.md5; then
				rm grub.cfg
				rm efibootgrub.md5
			fi
		fi
		)
		if [ "$MOUNTED" = "n" ]; then
			umount $MNT
		fi
	done < /var/efibootmenuinstall
}

display_the_menu() {
	while read name uuid path label; do
		if [ "$label" = "LABEL=hidden" ]; then
			continue
		elif [ "$label" = "LABEL=defaultscheme" ]; then
			echo " ($name)$path"
		else
			echo " ${label#LABEL=}"
		fi
	done < /var/efibootmenu
}

display_install_path() {
	if [ "$1" = "main" ]; then
		SHOW=$(grep efibootmenu /var/efibootmenuinstall)
	else
		SHOW=$(grep /EFI/BOOT /var/efibootmenuinstall)
	fi
	UUID=$(echo $SHOW|cut -d" " -f1)
	ESP_PATH=$(echo $SHOW|cut -d" " -f2)
	PARTITION=$(one_space "$(lsblk -l -o UUID,NAME)"|grep $UUID|cut -d" " -f2)
	echo "/dev/$PARTITION as ${ESP_PATH}.
"
}

update_grub() {
	if [ ! -f $ESPLIST ]; then
		list_the_ESP
	fi
	while read NAME PARTTYPE UUID PARENT; do
		set_mountpoint
		( cd $MOUNTPOINT
		MD5=$(find -name efibootgrub.md5)
		if [ ! "$MD5" = "" ]; then
			for i in $MD5; do
				( cd ${i%/efibootgrub.md5};
				if md5sum -c --quiet efibootgrub.md5; then
					cp $TMP/grub.cfg grub.cfg
					md5sum grub.cfg > efibootgrub.md5
				fi
				)		
			done
		fi
		)
		if [ "$MOUNTED" = "n" ]; then
			umount $MNT
		fi
	done < $ESPLIST
}

build_boot_loader() {
	grub_mkimage="$(find /bin/ /usr/bin /sbin /usr/sbin  -type f -name grub-mkimage -perm -u+x)"
	grub2_mkimage="$(find /bin/ /usr/bin /sbin /usr/sbin  -type f -name grub2-mkimage -perm -u+x)"
	if [ "$grub_mkimage" = "" ]; then
		if  [ "$grub2_mkimage" = "" ]; then
			echo "Neither grub-mkimage nor grub2-mkimage have been found."
			echo "Maybe grub (I mean grub2) is not installed?"
			read -p "Press Enter to quit."
			the_end
		else
			grub_mkimage=$grub2_mkimage
		fi
	fi
	if [ ! "$(echo "$grub_mkimage"|wc -l)" = "1" ]; then
		grub_mkimage=$(echo $grub_mkimage|sed -n 1p)
	fi
	$(basename $grub_mkimage) \
	--format=x86_64-efi \
	--output=/boot/efimultibootmenux64.efi \
	--prefix="" \
	--compression=xz \
	part_gpt part_msdos fat play chain reboot halt search search_fs_uuid efi_gop efi_uga all_video loadbios help at_keyboard usb_keyboard usb sleep extcmd normal
}

store_default_settings() {
	if [ ! "$USERTIMEOUT" = "" ]; then
		echo $USERTIMEOUT > /etc/efibootmenu/timeout
	fi
	if [ ! "$USERSOUND" = "" ]; then
		echo $USERSOUND > /etc/efibootmenu/sound
	fi
}

write_grub_config_file() {
	if [ -f /etc/efibootmenu/timeout ]; then
		TIMEOUT=$(grep . /etc/efibootmenu/timeout)
	fi
	if [ "$TIMEOUT" = "" ]; then
		TIMEOUT=15
	fi
	if [ -f /etc/efibootmenu/sound ]; then
		USERSOUND=$(grep . /etc/efibootmenu/sound)
	fi
	# Just in case the file be empty
	if [ "$USERSOUND" = "" ]; then
		USERSOUND=notknown
	fi
	if [ ! "ps -C espeakup --noheaders" = "" ] || \
	[ ! "ps -C orca --noheaders" = "" ] \
	[ "$USERSOUND" = "y" ]; then
		SOUND=y
	fi
	if [ "$USERSOUND" = "n" ]; then
		SOUND=n
	fi
	if [ "$SOUND" = "y"  ]; then
		PLAY="play 480 440 1"
	fi
	NUMENTRY=0
	# Write our specific default settings
	cat <<-EOF >$TMP/grub.cfg
	# Configuration file written by EFI3M, the EFI Multi-boot Manager Maker.
	set timeout=$TIMEOUT
	$PLAY
	set menu_color_normal=white/black
	set menu_color_highlight=white/blue
	EOF
	# Write a stanza for each line of /var/efibootmenu
	while read NAME UUID EFIPATH LABEL; do
		if echo $LABEL|grep -q "^LABEL=hidden"; then
			continue
		elif echo $LABEL|grep -q "^LABEL=defaultscheme"; then
			LABEL="($NAME)$EFIPATH"
		else LABEL=$(echo $LABEL|sed "s^LABEL=")
		fi
		NUMENTRY=$((${NUMENTRY}+1))
		PLAYTUNE=""
		if [ "$SOUND" = "y"  ] && [ $NUMENTRY -lt 36 ]; then
			PLAYTUNE="$(playtune $NUMENTRY)"
		fi
		cat <<-EOF >> $TMP/grub.cfg
		menuentry "$LABEL" {
		    insmod part_gpt
		    insmod part_msdos
		    insmod fat
		    search --fs-uuid --set=root $UUID
		    chainloader $EFIPATH
		    $PLAYTUNE
		}
		EOF
	done < /var/efibootmenu
	# Add global features.
	if [ ! "$SOUND" = "y" ];then
		HALT=""
		REBOOT=""
	fi
	cat <<-EOF >> $TMP/grub.cfg
	menuentry "Shut down computer" {
		$HALT
	    halt
	}
	menuentry "Reboot computer" {
		$REBOOT
	    reboot
	}
	EOF
}

list_the_ESP() {
	# List the accessible EFI system partitions or ESPs
	lsblk -l -o name,parttype,uuid,pkname|\
	grep -i -F -e "$ESPPARTTYPE" -e "$OSTYPE"|sed "s/ \{1,\}/ /g" > $ESPLIST
	if [ ! -s $ESPLIST ]; then # No EFI partitions
		echo "No EFI partition found, game over."
		return
	fi
	
}

make_boot_menu() {
	# Write a line for each menu entry in the file $ACCESSIBLE that will
	# be moved to /var/efibootmenu, creating or updating it.
	# We remove the stuff we previously installed in all accessible ESP
	# thus they won't be included in grub.cfg, which will be written
	# from /var/efibootmenu.
	# For this reason this function will only be called by
	# install_on_system_ESP, implying that install_on_USB_stick will
	# call install_on_system_ESP, not directly this function. But then
	# we won't suggest at the end of install_on_system_ESP to also
	# install on firmware. This won't hurt as anyway installing on
	# firmware needs to have already written EFI file in an ESP of which
	# the path will be written in the firmware menu boot entry.
	list_the_ESP
	ALREADY=$TMP/ALREADY
	NEW=$TMP/NEW
	touch $ALREADY $NEW
	#
	# We successively mount each ESP to find the boot loaders, and
	# (re)build the menu accordingly.
	# We take into account the previous customization of the menu.
	while read NAME PARTTYPE UUID PARENT; do
		# We discard the ESP on USB sticks.
		TRANSPORT=$(one_space "$(lsblk -l -o name,tran)"|grep "^$PARENT "|cut -d" " -f 2)
		HOTPLUG=$(one_space "$(lsblk -l -o name,hotplug)"|grep "^$PARENT "|cut -d" " -f 2)
		if [ "$TRANSPORT" = "usb" ] && [ "$HOTPLUG" = "1" ]; then
			continue
		fi
		# We mount successively each ESP to find the EFI boot loaders
		# that they could contain.
		set_mountpoint
		( cd $MOUNTPOINT
		# EFIPATHS will list all paths to efi boot loaders in this ESP
		EFIPATHS=$(find -iname "*.efi"|sed s/.//)
		# Select the EFI boot loaders and write a line for each.
		# For now we don't exclude the rEFInd boot manager although
        # it be somehow redundant.
        # We include all files ending in .efi not written by this script
        # and fulfilling at least one of the following conditions: 
        # "file" says they are 'PE32+ executable' and 'EFI application'
        # They lie in the "fallback" directory /EFI/BOOT
        # They lie in /EFI/tools.
		for EFIPATH in $EFIPATHS; do
			EFIAPP=$(file $MOUNTPOINT$EFIPATH|grep 'PE32+ executable'|grep 'EFI application')
			FALLBACK=$(echo $MOUNPOINT$EFIPATH|grep -i /EFI/BOOT)
			TOOLS=$(echo $MOUNTPOINT$EFIPATH|grep -i /EFI/tools)
			# REFIND=$(echo $MOUNTPOINT$EFIPATH|grep -i /efi/refind/refind_x64.efi)
			INCLUDE="n"
			if [ ! "$EFIAPP" = "" ] || [ ! "$FALLBACK" = "" ] || [ ! "$TOOLS" = "" ]; then
				INCLUDE="y"
			fi
			if [ "$INCLUDE" = "n" ]; then
				continue
			fi
			# /var/efibootmenu stores a menu with customized labels
			# in lines formatted this way:
			# Lines with a customized label:
			# $NAME $UUID $EFIPATH LABEL=<label>
			# Lines without a customized label:
			# $NAME $UUID $EFIPATH LABEL=defaultscheme
			# Hidden lines:
			# $NAME $UUID $EFIPATH LABEL=hidden
			#
			# When processing the currently accessible boot loaders we
			# match their UUID with the ones in /var/efibootmenu,
			# to apply the recorded customization to the new menu,
			# append to or remove from /var/efibootmenu lines
			# corresponding to efi boot loaders newly accessible or no
			# more accessible, respectively.
			LABEL="($NAME)$EFIPATH"
			if [ -f /var/efibootmenu ]; then
				LINE=$(grep $EFIPATH /var/efibootmenu|grep $UUID)
				if [ "$LINE" = "" ]; then
					# not yet registered in /var/efibootmenu
					LINE="$NAME $UUID $EFIPATH LABEL=defaultscheme"
					echo "$LINE" >> $NEW
				else CHOICE="$(echo $LINE|sed "s/.*LABEL=//")"
					if [ "$CHOICE" = "hidden" ]; then
						echo "$LINE" >> $ALREADY
						continue
					elif [ ! "$CHOICE" = "defaultscheme" ];then
						LABEL=$CHOICE
						echo "$LINE" >> $ALREADY
					else
						echo "$LINE" >> $ALREADY
					fi
				fi
			else
				LINE="$NAME $UUID $EFIPATH LABEL=defaultscheme"
				echo "$LINE" >> $NEW
			fi
		done
		)
		if [ "$MOUNTED" = "n" ]; then
			umount $MNT
		fi
	done < $ESPLIST
	# update /var/efibootmenu
	# We will first write in /var/efibootmenu the lines previously and
	# still there then the new ones. This is to avoid changing the order
	# of the boot entries possibly set by the user.
	# We exclude entries previously installed by us.
	if [ -f /var/efibootmenu ]; then
		mv /var/efibootmenu /var/efibootmenu.orig
		while read NAME UUID EFIPATH LABEL; do
			if [ ! -f /var/efibootmenuinstall ]; then
				INSTALLED=""
			else 
				INSTALLED=$(grep $UUID /var/efibootmenuinstall|grep $EFIPATH)
			fi
			if [ "$INSTALLED" = "" ]; then
				echo "$NAME $UUID $EFIPATH $LABEL" >> /var/efibootmenu
			fi
		done < /var/efibootmenu.orig
	fi
	while read NAME UUID EFIPATH LABEL; do
		if [ ! -f /var/efibootmenuinstall ]; then
			INSTALLED=""
		else 
			INSTALLED=$(grep $UUID /var/efibootmenuinstall|grep $EFIPATH)
		fi
		if [ "$INSTALLED" = "" ]; then
			echo "$NAME $UUID $EFIPATH $LABEL" >> /var/efibootmenu
		fi
	done < $NEW
	rm $ALREADY $NEW
	if [ -f /var/efibootmenu.orig ]; then
		rm /var/efibootmenu.orig
	fi
}

install_on_system_ESP() {
	clear
	echo "Please wait..."
	list_the_ESP
	# Output one line per ESP with these fields:
	# name parttype uuid pkname
	# pkname is the name of the device (parent of the partition)
	remove_previous_files
	make_boot_menu
	write_grub_config_file
	build_boot_loader
	# Initially we choose as ESP in which to write the EFI boot manager
	# the first one listed by lsblk, but if there is one in the device
	# that hosts the / partition we will prefer it.
	ESP_DEVICE=/dev/$(head -n 1 $ESPLIST|cut -d" " -f4)
	UUID=$(head -n 1 $ESPLIST|cut -d" " -f3)
	ROOT_UUID=$(findmnt -n -o UUID --mountpoint /)
	# The root device is the parent of the root partition, listed by
	# lsblk as PKNAME
	ROOT_NAME=$(one_space "$(lsblk -l -o UUID,PKNAME)"|grep $ROOT_UUID|cut -d" " -f2)
	while read name parttype uuid parent; do
		if [ "$parent" = "$ROOT_NAME" ]; then
			ESP="/dev/$name"
			ESP_DEVICE=/dev/"$parent"
			UUID="$uuid"
			break
		fi
	done < $ESPLIST
	set_mountpoint
	# We record the md5 checksum of BOOTx64.EFI alongside it.
	# We will propose to install the boot menu as /EFI/BOOT/BOOTx64.EFI
	# in $ESP if it doesn't exist yet or if the existing one has been
	# written by this script, which we check against its md5 checksum.
	INSTALLDIR=$MOUNTPOINT/EFI/efibootmenu
	if [ ! -d "$INSTALLDIR" ]; then
		mkdir -p $INSTALLDIR
	fi
	cp /boot/efimultibootmenux64.efi $INSTALLDIR/BOOTx64.EFI
	cp $TMP/grub.cfg $INSTALLDIR
	( cd $INSTALLDIR
	md5sum BOOTx64.EFI > efibootmenu.md5
	md5sum grub.cfg > efibootgrub.md5
	)
	echo "$UUID /EFI/efibootmenu/BOOTx64.EFI" > /var/efibootmenuinstall
	clear
	printf "The boot menu has been installed in "
	display_install_path main
	DEFAULTDIR=$MOUNTPOINT/EFI/BOOT
	DEFAULT=n
	if [ ! -d $DEFAULTDIR ]; then
		DEFAULT=y
	elif [ ! -f $DEFAULTDIR/BOOTx64.EFI ] && \
	[ ! -f $DEFAULTDIR/grub.cfg ]; then
		DEFAULT=y
	# We removed the previous files installed by this script from this
	# system,  but $DEFAULTDIR/BOOTx64 could have been written by this
	# script run from another system on the same machine. If that is the
	# case, we may replace it.
	else
		( cd $DEFAULTDIR
		if [ -f efibootmenu.md5 ]; then
			if md5sum -c --quiet efibootmenu.md5; then
				rm BOOTx64.EFI
				rm efibootmenu.md5
			fi
		fi
		if [ -f efibootgrub.md5 ]; then
			if md5sum -c --quiet efibootgrub.md5; then
				rm grub.cfg
				rm efibootgrub.md5
			fi
		fi
		)
		if [ ! -f $DEFAULTDIR/BOOTx64.EFI ] && \
		[ ! -f $DEFAULTDIR/grub.cfg ]; then
		DEFAULT=y
		fi
	fi
	if [ "$DEFAULT" = "y" ]; then
		mkdir -p $DEFAULTDIR
		CHOICE="n"
		read -p "Do you want to also install it in the default BOOT directory?
This can help insure that the boot menu will be displayed [y/N] " CHOICE
		if [ "$(to_lower "$CHOICE")" = "y" ]; then
			cp $INSTALLDIR/BOOTx64.EFI $DEFAULTDIR
			cp $INSTALLDIR/grub.cfg $DEFAULTDIR
			cp $INSTALLDIR/efibootmenu.md5 $DEFAULTDIR
			cp $INSTALLDIR/efibootgrub.md5 $DEFAULTDIR
			echo "$UUID /EFI/BOOT/BOOTx64.EFI" >> /var/efibootmenuinstall
			printf "The boot menu has also been installed in "
			display_install_path fallback
		else
			echo
		fi
	fi
	# Remove the boot entries to PE32+ executable that we previously
	# wrote, case occurring. There should be at most one.
	BOOTLIST=$(efibootmgr |grep -i "^BOOT"|efibootmgr |grep -i "^BOOT"|grep "EFI Boot menu"|sed "s/....\(....\).*/\1/")
	for i in $BOOTLIST; do
		efibootmgr -q -B -b $i
	done
	if [ "$MOUNTED" = "n" ]; then
		umount $MNT
	fi
	read -p "Do you want to add an entry for the boot menu in the firmware? [y/N] " FIRMWARE
	if [ "$FIRMWARE" = "Y" ] || [ "$FIRMWARE" = "y" ]; then
		install_in_firmware
	fi
echo "
You can display the menu now, then if need be edit it to modify, hide
or reorder the labels."
read -p "Do you want to display the menu now? [y/N]: " CHOICE
	if [ "$(to_lower "$CHOICE")" = "y" ]; then
		clear
		display_the_menu
		read -p "Press Enter to continue." dummy
	fi
}

install_in_firmware() {
	# We are optionally called by install_on_system_ESP.
	PARTNUM=$(echo $ESP|sed "s,${ESP_DEVICE},,")
	PARTNUM=$(echo $PARTNUM|sed s/[^[:digit:]]*//g)
	echo "
This entry has been added to the firmware's boot menu:"
	REPORT=$(efibootmgr -v -c -d $ESP_DEVICE -p $PARTNUM -l "\\EFI\\efibootmenu\\BOOTx64.EFI" -L "EFI Boot menu")
	echo "$REPORT"|grep "EFI Boot menu"
	read -p "Press Enter to continue. " dummy
}

install_on_USB_stick() {
	if [ ! -f /var/efibootmenu ]; then
		make_boot_menu
	fi
	if [ ! -f $TMP/grub.cfg ]; then
		write_grub_config_file
	fi
	build_boot_loader
	BADSTICK="n"
	STICK="y"
	BEFORE=$TMP/BEFORE
	AFTER=$TMP/AFTER
	while [ 0 ]; do
		clear
		if [ "$BADSTICK" = "y" ]; then
			read -p "Do you want to try again making an USB boot stick? [y/N]? " STICK
		fi
		if [ ! "$STICK" = "y" ] && [ ! "$STICK" = "Y" ]; then
			rm $BEFORE $AFTER
			return
		fi
		clear
		NEWSTICK=Y
		lsblk -l -o name,type,tran,hotplug|grep disk|grep usb|grep 1$|sort|sed "s/  .*//" > $BEFORE
		read -p "WARNING: the content of the USB stick will be irrecoverably deleted!

Type Q to quit, or plug in the USB stick. Then, press Enter: " ANSWER
		sleep 1
		if [ "$(to_lower "$ANSWER")" = "q" ]; then
			rm $BEFORE
			return
		fi
		lsblk -l -o name,type,tran,hotplug|grep disk|grep usb|grep 1$|sort|sed "s/  .*//" > $AFTER
        STICKNAME=""
		while read NEW_DEVICE; do
			if [ "$(grep $NEW_DEVICE $BEFORE)" = "" ]; then
				STICKNAME=$NEW_DEVICE
			fi
		done < $AFTER
		if [ "$STICKNAME" = "" ]; then
			printf "
No new device detected.
If the USB stick was already inserted, please remove it now.
Press Enter to continue. "
			read dummy
			BADSTICK="y"
			continue 
		else
			clear
			VENDOR=$(lsblk -l -o vendor,name|grep "${STICKNAME}$"|sed "s/[^[:space:]]*$//")
			MODEL=$(lsblk -l -o model,name|grep "${STICKNAME}$"|sed "s/[^[:space:]]*$//")
			SIZE=$(lsblk -l -o size,name|grep "${STICKNAME}$"|sed "s/[^[:space:]]*$//")
			echo "Found a device with these characteristics:
Vendor: $VENDOR
Model:  $MODEL
Size:   $SIZE"
			read -p "
Please check carefully this information, not to wipe the wrong device!

Is it the good device? [y/N]: " GOOD
			if [ "$GOOD" = "Y" ] || [ "$GOOD" = "y" ]; then
				break
			else
				clear
				echo -n "Please remove this device, then press Enter: "
				BADSTICK="y"
				read dummy
				continue 
			fi
		fi
	done
	STICKDEVICE=/dev/$STICKNAME
	### Format the USB stick and copy the EFI image there
	dd if=/dev/zero status=none of=$STICKDEVICE bs=512 count=1
	sgdisk -Z $STICKDEVICE 1>/dev/null
	sgdisk -n 1:2048:4095 -c:1:"EFI System Partition" -t 1:ef00 $STICKDEVICE 1>/dev/null
	partprobe $STICKDEVICE
	STICKESP=${STICKDEVICE}1
	mkfs.msdos -c -F12 $STICKESP 1>/dev/null
	mount $STICKESP $MNT
	mkdir -p $MNT/EFI/BOOT
	cp $TMP/grub.cfg $MNT/EFI/BOOT
	cp /boot/efimultibootmenux64.efi $MNT/EFI/BOOT/BOOTx64.EFI
	umount $MNT
	rm $BEFORE $AFTER
	echo "The boot menu has been written on the USB stick."
	echo "
You can display it now, then if need be edit it to modify, hide, or
or reorder the labels. You will need to write it again to the USB stick
to apply your modifications."
    read -p "Do you want to display the menu now? [y/N]: " CHOICE
	if [ "$(to_lower "$CHOICE")" = "y" ]; then
		display_the_menu
		read -p "Press Enter to continue." dummy
	fi
}

edit_label() {
LINE=$TMP/LINE
grep ^$CHOICE $MENU>$LINE
read LINENUMBER name uuid path label < $LINE
while [ 0 ]; do
	clear
	echo "$path in partition /dev/$name"
	if [ "$label" = "LABEL=hidden" ]; then
		echo "is currently not displayed in the menu"
	elif [ "$label" = "LABEL=defaultscheme" ]; then
		echo "is currently displayed like this:"
		echo "($name)$path"
	else 
		echo "is currently displayed: \"${label#LABEL=}\""
		echo
	fi
	echo
	read -p "Please type:
H to Hide this boot entry,
D to keep or reset the Default label,
or the new label (5 to 40 characters, spaces allowed but not quotes),
then press Enter: " LABEL
	if [ "$(to_lower "$LABEL")" = "h" ]; then
		sed "/^$LINENUMBER /s.*$LINENUMBER $name $uuid $path LABEL=hidden" $MENU > somedummmyfile
		mv somedummmyfile $MENU
		rm $LINE
		return
	elif   [ "$(to_lower "$LABEL")" = "d" ]; then
		sed "/^$LINENUMBER /s.*$LINENUMBER $name $uuid $path LABEL=defaultscheme" $MENU > somedummmyfile
		mv somedummmyfile $MENU
		rm $LINE
		return
	else
		if [ ${#LABEL} -lt 5 ] || [ ${#LABEL} -gt 40 ]; then
			read -p "The label should have between 5 and 4O characters.
Press Enter then try again." dummy
			continue
		elif echo $LABEL|grep -q -e '"' -e "'"; then
			read -p "Characters \" and ' are not allowed in the label.
Press Enter then try again." dummy
			continue
		elif echo $LABEL|grep -q [^[:print:]]; then
			read -p "Only printable characters, including spaces, are allowed in the label.
Press Enter then try again." dummy
			continue
		else
			sed "/^$LINENUMBER /s.*$LINENUMBER $name $uuid $path LABEL=$LABEL" $MENU > somedummmyfile
			mv somedummmyfile $MENU
			rm $LINE
			return
		fi
		rm $LINE
		return
	fi
done
}

change_the_boot_order() {
	NEWMENU=$TMP/NEWMENU
	MENU="$1"
	MAXLINENUMBER=$2
	while [ 0 ]; do
		clear

		echo "Current menu:"
		while read LINENUMBER name uuid path label; do
			printf $LINENUMBER
			# Only the 99 first lines will be properly aligned ;)
			if [ ${#LINENUMBER} -eq 1 ]; then
				printf " "
			fi
			if [ "$label" = "LABEL=hidden" ]; then
				echo " ($name)$path (not displayed)"
			elif [ "$label" = "LABEL=defaultscheme" ]; then
				echo " ($name)$path"
			else
				echo " ${label#LABEL=}"
			fi
		done < $MENU
		echo "
Type a line number to move this line up.

Just press Enter when you are done to return to the main menu and
validate your modifications."
		read -p "Line number: " NUMBER
		if [ "$NUMBER" = "" ]; then
			rm $NEWMENU
			return
		fi
		if echo $NUMBER|grep -q [^[:digit:]]; then 
			read -p "Not a number, press Enter to continue." dummy
			continue
		elif [ $NUMBER -lt 2 ] || [ $NUMBER -gt $MAXLINENUMBER ]; then
			echo "The line number should be between 2 and $MAXLINENUMBER."
			read -p "Press Enter to continue. " dummy
			continue
		else
			if [ $NUMBER -gt 2 ]; then
				sed -n 1,$((${NUMBER}-2))p $MENU>>$NEWMENU
			fi
			sed -n ${NUMBER}p $MENU>>$NEWMENU
			sed -n $((${NUMBER}-1))p $MENU>>$NEWMENU
			sed -n $((${NUMBER}+1)),${MAXLINENUMBER}p $MENU>>$NEWMENU
		fi
		NEWNUMBER=0
		echo -n "" > $MENU
		while read  OLDNUMBER name uuid path label; do
		NEWNUMBER=$(($NEWNUMBER + 1))
		echo "$NEWNUMBER $name $uuid $path $label" >> $MENU
	done < $NEWMENU
	echo -n "" > $NEWMENU
	done
}
	
edit_the_menu() {
	make_boot_menu
	CHOICE=""
	MENU=$TMP/MENU
	LINENUMBER=0
	while read line; do
		LINENUMBER=$(($LINENUMBER + 1))
		echo "$LINENUMBER $line" >> $MENU
	done < /var/efibootmenu
	MAXLINENUMBER=$LINENUMBER
		DONE=n
	REMOVE=n
	HIDEINSTALLEDMENU=y
	while [ 0 ]; do
		clear
		echo "Current menu (custom labels on the second line):"
		echo
		while read LINENUMBER name uuid path label; do
			printf $LINENUMBER
			# Only the 99 first lines will be properly aligned ;)
			if [ ${#LINENUMBER} -eq 1 ]; then
				printf " "
			fi
			if [ "$label" = "LABEL=hidden" ]; then
				echo " ($name)$path (not displayed)"
			elif [ "$label" = "LABEL=defaultscheme" ]; then
				echo " ($name)$path"
			else
				echo " ($name)$path"
				echo "   Label: ${label#LABEL=}"
			fi
			
		done < $MENU
		echo "
Type:
a number between 1 and $MAXLINENUMBER to select a boot entry then set
  the label used to display it in the boot menu,
D to set the Delay before auto boot,
M for a Mute menu, S for a menu with Sound,"
if [ $MAXLINENUMBER -gt 1 ]; then
	echo "O to modify the boot Order,"
fi
read -p "V to Validate your modifications.

Just press Enter to undo all modifications and return to the main menu.

Your choice: " CHOICE
		if [ "$CHOICE" = "" ]; then
			rm $MENU
			return
		fi
		if [ "$(to_lower "$CHOICE")" = "d" ]; then
			while [ 0 ]; do 
				clear 
				read -p "Please type the delay in seconds before automatically booting the first
menu entry (between 5 and 60 seconds) " USERTIMEOUT
				if echo $TIMEOUT|grep -q [^[:digit:]]; then 
					read -p "Not a number, press Enter and try again. " dummy
					continue
				fi
				if [ $USERTIMEOUT -lt 5 ] || [ $USERTIMEOUT -gt 60 ]; then
					read -p "The delay should be between 5 and 60, press Enter and try again " dummy
					continue 
				fi
				echo "The delay will be $USERTIMEOUT seconds if you validate this setting."
				read -p "Press Enter to continue. " dummy
				break
			done
		elif [ "$(to_lower "$CHOICE")" = "s" ]; then
			USERSOUND=y
			clear
			echo "You will have a menu with sound if you validate this setting." 
			read -p "Press Enter to continue. " dummy
		elif [ "$(to_lower "$CHOICE")" = "m" ]; then
			USERSOUND=n
			clear
			echo "You will have a mute menu if you validate this setting." 
			read -p "Press Enter to continue. " dummy
		elif [ "$(to_lower "$CHOICE")" = "v" ]; then
			sed "s^[^ ]*" $MENU > /var/efibootmenu
			store_default_settings
			write_grub_config_file
			update_grub
			rm $MENU
			echo "
The boot menu is up to date.
			"
			read -p "Press Enter to continue. " dummy
			return
		elif [ "$(to_lower "$CHOICE")" = "o" ] &&
		[ $MAXLINENUMBER -ge 2 ]; then
			change_the_boot_order $MENU $MAXLINENUMBER
		elif echo $CHOICE|grep -q [^[:digit:]]; then 
			read -p "Wrong typing, press Enter to continue." dummy
		elif [ $CHOICE -eq 0 ] || [ $CHOICE -gt $MAXLINENUMBER ]; then
			echo "The line number should be between 1 and $MAXLINENUMBER."
			read -p "Press Enter to continue. " dummy
		else
			edit_label
		fi
	done
}

the_end() {
	rm -f $ESPLIST
	rm -f $TMP/grub.cfg
	rmdir $MNT
	rmdir $TMP
	clear
	echo "Good bye."
	exit
}

while [ 0 ]; do
	clear
	echo "*** EFI multiboot menu maker ***
	
Available features:
1 Build and install the multiboot menu on your computer
2 Make a rescue USB stick providing the boot menu
3 Customize the boot menu
4 Information about EFI3M

Just press Enter to quit.
"
read -p "Your choice: " CHOICE
	case $CHOICE in
		1) install_on_system_ESP ;;
		2) install_on_USB_stick ;;
		3) edit_the_menu ;;
		4) About_EFI3M ;;
		*) the_end
	esac
done