#! /bin/sh
#----------------------------------------------------------------------------
# /var/install/bin/update-bootloader - update boot configuration
#
# Creation   :  2021-04-23 hbfl
# Last Update:  $Id$
#
# Copyright (c) 2001-@@YEAR@@ the eisfair team, team(at)eisfar(dot)org
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#----------------------------------------------------------------------------

. /var/install/include/eislib

do_debug="no"
system="$(lsb_release -ds)"

#-----------------------------------------------------------------------------
# show help
#-----------------------------------------------------------------------------
show_help()
{
cat <<EOF

Update boot configuration

Usage: update-bootloader [OPTIONS]

options:
    --generate-new     create a new bootloader configuration
    --use-existing     activate a existing bootloader
                       configuration for a new initrd

EOF

}

#-----------------------------------------------------------------------------
# when running in vmware, issue this warning
#-----------------------------------------------------------------------------
print_vmware_warning()
{
    if /usr/bin/lscpu | /usr/bin/grep -qi 'vmware'
    then
        echo
        mecho --warn 'Please stop this virtual machine and set'
        mecho --warn '     disk.EnableUUID = "TRUE"'
        mecho --warn 'in vmx file of this virtual machine.'
        mecho --warn 'Then install this package again.'
        echo
    fi
}

#-----------------------------------------------------------------------------
# read a single value for a given key from lilo.conf
#-----------------------------------------------------------------------------
lookup_value_from_lilo_conf()
{
    if "${lilo_conf}"
    then
        local key="${1}"
        local value=$(/usr/bin/grep -E "${key}[[:blank:]]+=" /etc/lilo.conf |
            /usr/bin/grep -v '^#'      |
            /usr/bin/head -1           |
            /usr/bin/cut -d'=' -f2-    |
            /usr/bin/sed 's#"##g'      |
            /usr/bin/sed 's#[#].*$##g' |
            /usr/bin/sed -e 's#^[[:blank:]]*##g' -e 's#[[:blank:]]*$##g')
        echo "${value}"
    fi
}

#-----------------------------------------------------------------------------
# read a single value for a given key from lilo.conf
#-----------------------------------------------------------------------------
lookup_append_from_boot_conf()
{
    if [ -f "${boot_conf}" ]
    then
        local key="${1}"
        local value=$(/usr/bin/grep -E "${key}[[:blank:]]" ${boot_conf} |
            /usr/bin/grep -v '^#'         |
            /usr/bin/head -1              |
            /usr/bin/sed "s|^.*${key} ||" |
            /usr/bin/sed 's|root=[^ ]* ||')
        echo "${value}"
    fi
}

#-----------------------------------------------------------------------------
# read a single value for a given key from lilo.conf (apply filter)
#-----------------------------------------------------------------------------
lookup_value_from_lilo_conf_with_filter()
{
    if "${lilo_conf}"
    then
        local key="${1}"
        local filter="${2}"
        local value=$(/usr/bin/grep -E "${key}[[:blank:]]+=" /etc/lilo.conf |
            /usr/bin/grep -v '^#'        |
            /usr/bin/grep -v "${filter}" |
            /usr/bin/head -1             |
            /usr/bin/cut -d'=' -f2-      |
            /usr/bin/sed 's#"##g'        |
            /usr/bin/sed 's#[#].*$##g'   |
            /usr/bin/sed -e 's#^[[:blank:]]*##g' -e 's#[[:blank:]]*$##g')
        echo "${value}"
    fi
}

#-----------------------------------------------------------------------------
# lookup device for a given mount point or path
#-----------------------------------------------------------------------------
lookup_device_from_path()
{
    local mountpoint="${1}"

    hex_dev_number=$(LANG=C; /usr/bin/stat -c %D ${mountpoint}) #|
        #             grep Device: |
        #             cut -f 1 -d '/' |
        #             cut -f 2 -d ' ' |
        #             sed 's#h##g')

    if [ ${#hex_dev_number} -lt 4 ]
    then
        hex_dev_number="0${hex_dev_number}"
    fi

    if [ ${#hex_dev_number} -eq 4 ]
    then
        local major=$(printf "%d\n" "0x${hex_dev_number:0:2}")
        local minor=$(printf "%d\n" "0x${hex_dev_number:2:2}")
    else
        local major=$(printf "%d\n" "0x${hex_dev_number:0:3}")
        local minor=$(printf "%d\n" "0x${hex_dev_number:3:2}")
    fi

    for file in $(/usr/bin/find /sys/dev/block -name "${major}:${minor}")
    do
        source ${file}/uevent
        echo "/dev/${DEVNAME}"
    done
}

#-----------------------------------------------------------------------------
# read device file from link in /dev/disk/by_id/*
#-----------------------------------------------------------------------------
lookup_device_from_link()
{
    local id="${1}"
    echo $(/usr/bin/readlink "${id}" | /usr/bin/sed 's#^\.\.\/\.\.\/#\/dev\/#g')
}

#-----------------------------------------------------------------------------
# check if device is a virtual disk
#-----------------------------------------------------------------------------
is_disk_a_virtual_device()
{
    echo "${1}" | /usr/bin/grep -q "^/dev/xvd"
    return "${?}"
}

#-----------------------------------------------------------------------------
# check if device is a softraid disk
#-----------------------------------------------------------------------------
is_disk_a_softraid_device()
{
    echo "${1}" | /usr/bin/grep -q '^/dev/md'
    return "${?}"
}

#-----------------------------------------------------------------------------
# read list of uuids in /dev/disk/uuid/* and lookup the uuid for the device
#-----------------------------------------------------------------------------
lookup_volume_uuid_from_list()
{
    local link=''
    local disk_device="${1}"
    if [ ! -d /dev/disk/by-uuid ]
    then
        return
    fi

    local uuid_list=$(/usr/bin/ls /dev/disk/by-uuid/*)

    for link in ${uuid_list}
    do
        local newdevice="$(lookup_device_from_link ${link})"
        if [ "${disk_device}" = "${newdevice}" ]
        then
            link=$(echo ${link} | /usr/bin/sed 's#/dev/disk/by-uuid/##g')
            echo "UUID=${link}"
            return
        fi
    done
}

#-----------------------------------------------------------------------------
# print uuids in /dev/disk/by_uuid/* for debug purpose
#-----------------------------------------------------------------------------
print_volume_uuids_from_list()
{
    if [ ! -d /dev/disk/by-uuid ]
    then
        return
    fi

    local uuid_list=$(ls /dev/disk/by-uuid/*)

    mecho --info "Entries in /dev/disk/by-uuid:"

    for link in ${uuid_list}
    do
        local newdevice="$(lookup_device_from_link ${link})"
        echo "  ${newdevice} --> UUID=${link}"
    done
}

#-----------------------------------------------------------------------------
# find suitable initrd name for kernel image
#-----------------------------------------------------------------------------
lookup_initrd_name()
{
    local kernel="${1}"

    if [ "${kernel}" == "kernel" ]
    then
        echo 'initrd.gz'
        return
    fi

    if [ "${kernel}" == "old-kernel" ]
    then
        echo 'old-initrd.gz'
        return
    fi

    local kernel_name=$(echo ${kernel} | cut -d'-' -f2-)
    echo "initrd-${kernel_name}.gz"
}

#-----------------------------------------------------------------------------
# inspect /boot for kernel images in correct order
#-----------------------------------------------------------------------------
lookup_kernel_images()
{
    local kernels='kernel'
    local kernel

    if [ -L '/boot/kernel' ]
    then
        # new configuration (prefer versioned kernels over old-kernel)
        local versioned_kernels="$(/usr/bin/ls /boot/kernel-* 2> /dev/null |
                     /usr/bin/sed 's#/boot/##g'  |
                     /usr/bin/sort -r)"

        for kernel in ${versioned_kernels}
        do
            local initrd_name="$(lookup_initrd_name ${kernel})"
            if [ -f "/boot/${initrd_name}" ]
            then
                kernels="${kernels} ${kernel}"
            fi
        done

        if [ -f '/boot/old-kernel' ]
        then
            kernels="${kernels} old-kernel"
        fi
    else
        # old configuration (prefer old-kernel over versioned kernels)
        if [ -f "/boot/old-kernel" ]
        then
            kernels="${kernels} old-kernel"
        fi

        local versioned_kernels="$(/usr/bin/ls /boot/kernel-* 2> /dev/null |
                     /usr/bin/sed 's#/boot/##g'  |
                     /usr/bin/sort -r)"

        # only add kernel images with valid initrd
        for kernel in ${versioned_kernels}
        do
            local initrd_name="$(lookup_initrd_name ${kernel})"
            if [ -f "/boot/${initrd_name}" ]
            then
                kernels="${kernels} ${kernel}"
            fi
        done
    fi

    echo "${kernels}"
}

#-----------------------------------------------------------------------------
# lookup name of kernel for label entry (max length = 15 characters)
#-----------------------------------------------------------------------------
lookup_kernel_name()
{
    local kernel="${1}"

    if [ "${kernel}" == "old-kernel" ]
    then
        echo 'oldeis'
        return
    fi

    if [ "${kernel}" == "kernel" ]
    then
        echo 'eis'
        return
    fi

    local kernel_name=$(echo ${kernel} | /usr/bin/cut -d'-' -f2-)
    echo "$(echo ${kernel_name} | /usr/bin/sed "s#${system}-##g")"
}

#-----------------------------------------------------------------------------
# add default append arguments, if not present
#-----------------------------------------------------------------------------
extend_append_args()
{
    local append="${@}"

    if [ -z "${append}" ]
    then
        # append-zeile existiert nicht, 
        # setze consoleblank=600 (beim 5er Kernel ist default 0)
        append='consoleblank=600'
    else
        # zeile existiert
        if ! echo "${append}" | /usr/bin/grep -q 'consoleblank=600'
        then
            # setze consoleblank=600 (beim 5er Kernel ist default 0)
            append="${append} consoleblank=600"
        fi
    fi

    echo "${append}"
}

#-----------------------------------------------------------------------------
# write kernel image to bootloader.conf
#-----------------------------------------------------------------------------
write_kernel_image()
{
    local kernel="${1}"
    local root_uuid="${2}"
    local vga="${3}"
    local append_args="${4}"

    if [ -n "${vga}" ]
    then
        if ! echo "${append_args}" | /usr/bin/grep -q 'vga'
        then
            # setze vga
            append_args="${append_args} vga=${vga}"
        fi
    fi

    echo ''
    echo "LABEL $(lookup_kernel_name ${kernel})"
    echo "    MENU LABEL $(lookup_kernel_name ${kernel})"
    echo "    KERNEL ../${kernel}"
    echo "    INITRD ../$(lookup_initrd_name ${kernel})"
    echo "    APPEND root=${root_uuid} ${append_args}"
}

#-----------------------------------------------------------------------------
# create config
#-----------------------------------------------------------------------------
create_config()
{
    # read boot configuration
    local disk_byid=''

    local disk_dev=''
    local boot_byid=''
    local boot_dev=''
    local root_uuid=''
    local root_dev=''

    if "${lilo_conf}"
    then
        local vga="$(lookup_value_from_lilo_conf_with_filter 'vga' 'normal')"
        local append_args="$(lookup_value_from_lilo_conf 'append')"
    fi

    if [ -f "${boot_conf}" ]
    then
        local append_args="$(lookup_append_from_boot_conf 'APPEND')"
    fi

    # lookup root partition
    root_partition="$(lookup_device_from_path '/')"
    if [ -z "${root_partition}" ]
    then
        mecho --error "Failed to lookup block device for root partition"
        exit 1
    fi

    root_uuid="$(lookup_volume_uuid_from_list ${root_partition})"
    if [ -z "${root_uuid}" ]
    then
        mecho --error "Cannot translate root disk partition ${root_partition} to /dev/disk/by-uuid/!"
        echo
        print_volume_uuids_from_list
        exit 1
    fi

    # extra processing of values
    append_args="$(extend_append_args "${append_args}")"

    kernel_images="$(lookup_kernel_images)"
    if [ -z "${kernel_images}" ]
    then
        mecho --error "No kernel images found!"
        exit 1
    fi

    # show values
    if [ "${do_debug}" = "yes" ]
    then
        echo -n "root_uuid       = "; mecho --info "${root_uuid}"
        echo -n "append_args     = "; mecho --info "${append_args}"
        echo -n "kernel_images   = "; mecho --info "${kernel_images}"
        echo
    fi

    # write new config file
    {
        echo '#-------------------------------------------------------------------------'
        echo '# /boot/extlinux/extlinux.conf - bootloader configuration'
        echo "# created: ${EISDATE} ${EISTIME}"
        echo '#-------------------------------------------------------------------------'
        echo
        echo 'PATH com32'
        echo 'UI menu.c32'
        echo 'DEFAULT eis'
        echo 'PROMPT 0'
        echo 'MENU TITLE eisfair - EXTlinux - Bootmenu'
        echo 'TIMEOUT 30'

        for kernel in ${kernel_images}
        do
            write_kernel_image "${kernel}" \
                "${root_uuid}"             \
                "${vga}"                   \
                "${append_args}"
        done
    } > ${boot_conf}

    if [ ${?} -ne 0 ]
    then
        mecho --error "Failed to write to ${boot_conf}!"
        exit 1
    fi

    if "${lilo_conf}"
    then
        /usr/bin/mv /etc/lilo.conf /etc/lilo.conf.OLD
    fi
}

#-----------------------------------------------------------------------------
# main program
#-----------------------------------------------------------------------------
main()
{
    boot_dir='/boot/extlinux'
    /usr/bin/mkdir -p ${boot_dir}
    boot_conf=${boot_dir}/extlinux.conf

    lilo_conf=false
    if [ -f '/etc/lilo.conf' ]
    then
        lilo_conf=true
    fi

    while [ "${1:0:2}" = "--" ]
    do
        case "${1}" in
        --help)
            shift
            show_help
            exit 0
            ;;
        --generate-new)
            shift
            create_config
            exit 0
            ;;
        --use-existing)
            shift
      #      create_config
      #      quiet=true
            exit 0
            ;;
        *)
            echo "error: invalid switch \"${1}\"!" >&2
            show_help
            exit 1
            ;;
         esac
    done

    if [ -z "${@}" ]
    then
        create_config
    else
        show_help
        exit 0
    fi

    exit 0
}

#-----------------------------------------------------------------------------
# call function main
#-----------------------------------------------------------------------------
main "${@}"

#-----------------------------------------------------------------------------
# end
#-----------------------------------------------------------------------------