remake

#!/bin/bash
#================================================================================================
#
# This file is licensed under the terms of the GNU General Public
# License version 2. This program is licensed "as is" without any
# warranty of any kind, whether express or implied.
#
# This file is a part of the Remake OpenWrt
# https://github.com/ophub/amlogic-s9xxx-openwrt
#
# Description: Automated OpenWrt Image Builder
# Copyright (C) 2020~ https://github.com/openwrt/openwrt
# Copyright (C) 2020~ https://github.com/coolsnowwolf/lede
# Copyright (C) 2020~ https://github.com/immortalwrt/immortalwrt
# Copyright (C) 2020~ https://github.com/unifreq/openwrt_packit
# Copyright (C) 2021~ https://github.com/ophub/amlogic-s9xxx-armbian/blob/main/CONTRIBUTORS.md
# Copyright (C) 2020~ https://github.com/ophub/amlogic-s9xxx-openwrt
#
# Command: sudo ./remake
# Command optional parameters please refer to the source code repository
#
#======================================== Functions list ========================================
#
# error_msg          : Output error message
# process_msg        : Output process message
# clean_model_conf   : Clean the model configuration file
# mount_try          : Mount the image file with retry
# get_textoffset     : Get kernel TEXT_OFFSET
#
# init_var           : Initialize all variables
# check_data         : Check the validity of the data
# find_openwrt       : Find OpenWrt file (openwrt-armsr/*rootfs.tar.gz)
# git_pull_dir       : Clone files from a git repository
# download_depends   : Download the dependency files
# query_kernel       : Query the latest kernel version
# check_kernel       : Check kernel files integrity
# download_kernel    : Download the kernel files
#
# confirm_version    : Confirm version type
# make_image         : Create the OpenWrt image file
# extract_openwrt    : Extract OpenWrt files
# replace_kernel     : Replace kernel files
# refactor_bootfs    : Configure bootfs partition
# refactor_rootfs    : Configure rootfs partition
# clean_tmp          : Clean up temporary files
#
# loop_make          : Loop to make OpenWrt files
#
#================================ Set make environment variables ================================
#
# Related file storage path
current_path="${PWD}"
make_path="${current_path}/openwrt"
tmp_path="${make_path}/tmp"
out_path="${make_path}/out"
openwrt_path="${current_path}/openwrt-armsr"
openwrt_rootfs_file="*rootfs.tar.gz"
resource_path="${current_path}/make-openwrt"
kernel_path="${resource_path}/kernel"
uboot_path="${resource_path}/u-boot"
common_files="${resource_path}/openwrt-files/common-files"
platform_files="${resource_path}/openwrt-files/platform-files"
different_files="${resource_path}/openwrt-files/different-files"
firmware_path="${common_files}/lib/firmware"
model_conf="${common_files}/etc/model_database.conf"
model_txt="${common_files}/etc/model_database.txt"
[[ -d "${make_path}" ]] || mkdir -p ${make_path}

# System operation environment
arch_info="$(uname -m)"
host_release="$(cat /etc/os-release | grep '^VERSION_CODENAME=.*' | cut -d'=' -f2)"
# Board-specific release configuration for special devices, such as [ s922x-oes-plus ]
board_release_file="etc/openwrt-board-release.conf"
# Add custom OpenWrt firmware information
op_release="etc/flippy-openwrt-release"
ophub_release_file="etc/ophub-release"

# Dependency files download repository
depends_repo="https://github.com/ophub/amlogic-s9xxx-armbian"
# U-BOOT files download repository
uboot_repo="https://github.com/ophub/u-boot"
# Firmware files download repository
firmware_repo="https://github.com/ophub/firmware"
# Install/Update script files download repository
script_repo="https://github.com/ophub/luci-app-amlogic"

# Set the kernel download repository
kernel_repo="https://github.com/ophub/kernel"
# Set the kernel tags (kernel_xxx) that can be overridden via the [ -u ] parameter
default_tags="stable"
kernel_usage=""
# Set the list of kernels used by default(Selectable version)
stable_kernel=("6.12.y" "6.18.y")
flippy_kernel=(${stable_kernel[@]})
beta_kernel=(${stable_kernel[@]})
rk3588_kernel=("6.1.y")
rk35xx_kernel=("6.1.y")
h6_kernel=("6.6.y")
specific_6xy=("6.1.y" "6.6.y" "6.12.y" "6.18.y")
specific_5xy=("5.10.y" "5.15.y")
# Set to automatically use the latest kernel
auto_kernel="true"
# Initialize the kernel tags array
declare -A tags_list

# Set the Amlogic u-boot series (u-boot-xxx.bin)
uboot_meson_gxl=("p201.bin" "p212.bin" "s905x-s912.bin" "n1.bin" "r3300l.bin")
uboot_meson_gxm=("p212.bin" "s905x-s912.bin" "zyxq.bin")
uboot_meson_g12a=("x96max.bin" "e900v22c.bin")
uboot_meson_g12b=("gtking.bin" "gtkingpro.bin" "gtkingpro-rev-a.bin" "s905x2-s922.bin")
uboot_meson_sm1=("x96maxplus.bin" "ugoos-x3.bin" "tx3-qz.bin" "tx3-bz.bin" "skyworth-lb2004.bin")
uboot_meson_gxbb=("p201.bin" "s905.bin")

# Set OpenWrt default IP address
openwrt_ip="192.168.1.1"
ip_regex="^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"

# Initialize the target build device list
make_board="all"
# Set OpenWrt firmware size (Unit: MiB, boot_mb >= 256, root_mb >= 1024)
boot_mb="384"
root_mb="1280"
# Set OpenWrt builder signature
builder_name=""

# Set font color
STEPS="[\033[95m STEPS \033[0m]"
INFO="[\033[94m INFO \033[0m]"
NOTE="[\033[93m NOTE \033[0m]"
WARNING="[\033[93m WARNING \033[0m]"
SUCCESS="[\033[92m SUCCESS \033[0m]"
ERROR="[\033[91m ERROR \033[0m]"
#
#================================================================================================

error_msg() {
    echo -e " [💔] ${1}"
    exit 1
}

process_msg() {
    echo -e " [🌿] ${1}"
}

clean_model_conf() {
    [[ -f "${model_conf}" ]] || return 1
    sed -e 's/NA//g' -e 's/NULL//g' -e 's/[ ][ ]*//g' "${model_conf}" | grep -E '^[^#].+'
}

mount_try() {
    # Check mount parameters
    local m_type="${1}"
    local m_dev="${2}"
    local m_target="${3}"
    [[ -n "${m_type}" && -n "${m_dev}" && -n "${m_target}" ]] || {
        error_msg "Incomplete mount parameters: [ ${m_type}, ${m_dev}, ${m_target} ]"
    }

    local t=1
    local max_try=10
    while [[ "${t}" -le "${max_try}" ]]; do
        # Mount according to the image partition format; rely on command's exit status directly.
        if [[ "${m_type}" == "btrfs" ]]; then
            if mount -t "${m_type}" -o discard,compress=zstd:6 "${m_dev}" "${m_target}" 2>/dev/null; then
                return 0
            fi
        else
            if mount -t "${m_type}" -o discard "${m_dev}" "${m_target}" 2>/dev/null; then
                return 0
            fi
        fi

        # Mount failed: ensure target is unmounted before retry, then back off.
        sync
        umount -l "${m_target}" 2>/dev/null || true
        sleep 3
        ((t++))
    done
    error_msg "[ ${max_try} ] attempts to mount [ ${m_dev} -> ${m_target} ] failed."
}

get_textoffset() {
    vmlinuz_name="${1}"
    need_overload="yes"
    [[ -f "${vmlinuz_name}" ]] || return 0
    # With TEXT_OFFSET patch is [ 0108 ], without TEXT_OFFSET patch is [ 0000 ]
    [[ "$(hexdump -n 15 -x "${vmlinuz_name}" 2>/dev/null | head -n 1 | awk '{print $7}')" == "0108" ]] && need_overload="no"
}

init_var() {
    echo -e "${STEPS} Initializing build variables..."

    # If it is followed by [ : ], it means that the option requires a parameter value
    local options="b:r:u:k:a:p:s:n:"
    parsed_args=$(getopt -o "${options}" -- "${@}")
    [[ ${?} -ne 0 ]] && error_msg "Parameter parsing failed."
    eval set -- "${parsed_args}"

    while true; do
        case "${1}" in
        -b | --Board)
            if [[ -n "${2}" ]]; then
                make_board="${2// /}"
                shift 2
            else
                error_msg "Invalid -b parameter [ ${2} ]!"
            fi
            ;;
        -r | --kernelRepository)
            if [[ -n "${2}" ]]; then
                kernel_repo="${2}"
                shift 2
            else
                error_msg "Invalid -r parameter [ ${2} ]!"
            fi
            ;;
        -u | --kernelUsage)
            if [[ -n "${2}" ]]; then
                kernel_usage="${2//kernel_/}"
                shift 2
            else
                error_msg "Invalid -u parameter [ ${2} ]!"
            fi
            ;;
        -k | --Kernel)
            if [[ -n "${2}" ]]; then
                oldIFS="${IFS}"
                IFS="_"
                stable_kernel=(${2})
                flippy_kernel=(${2})
                beta_kernel=(${2})
                specific_kernel=(${2})
                IFS="${oldIFS}"
                shift 2
            else
                error_msg "Invalid -k parameter [ ${2} ]!"
            fi
            ;;
        -a | --Autokernel)
            if [[ -n "${2}" ]]; then
                auto_kernel="${2}"
                shift 2
            else
                error_msg "Invalid -a parameter [ ${2} ]!"
            fi
            ;;
        -p | --IP)
            if [[ -n "${2}" && "${2}" =~ ${ip_regex} ]]; then
                openwrt_ip="${2}"
                shift 2
            else
                error_msg "Invalid -p parameter [ ${2} ]!"
            fi
            ;;
        -s | --Size)
            if [[ -n "${2}" ]]; then
                img_mb="${2}"
                shift 2
            else
                error_msg "Invalid -s parameter [ ${2} ]!"
            fi
            ;;
        -n | --BuilderName)
            if [[ -n "${2}" ]]; then
                builder_name="${2// /}"
                shift 2
            else
                error_msg "Invalid -n parameter [ ${2} ]!"
            fi
            ;;
        --)
            shift
            break
            ;;
        *)
            [[ -n "${1}" ]] && error_msg "Invalid option [ ${1} ]!"
            break
            ;;
        esac
    done

    # Set the image size, such as [ -s 512/2560 ] or [ -s 2560 ]
    [[ -n "${img_mb}" ]] && {
        if [[ "${img_mb}" =~ / ]]; then
            boot_mb="${img_mb%%/*}"
            root_mb="${img_mb##*/}"
        else
            root_mb="${img_mb}"
        fi
    }

    # Validate partition sizes (Unit: MiB). Boot must be >= 256 and root >= 1024 to fit.
    [[ "${boot_mb}" =~ ^[0-9]+$ && "${boot_mb}" -ge 256 ]] || error_msg "Invalid boot partition size: [ ${boot_mb} ]"
    [[ "${root_mb}" =~ ^[0-9]+$ && "${root_mb}" -ge 1024 ]] || error_msg "Invalid rootfs partition size: [ ${root_mb} ]"
}

check_data() {
    # Columns of ${model_conf}:
    # 1.ID  2.MODEL  3.SOC  4.FDTFILE  5.UBOOT_OVERLOAD  6.MAINLINE_UBOOT  7.BOOTLOADER_IMG  8.DESCRIPTION
    # 9.KERNEL_TAGS  10.PLATFORM  11.FAMILY  12.BOOT_CONF  13.CONTRIBUTORS  14.BOARD  15.BUILD
    [[ -f "${model_conf}" ]] || error_msg "Missing model config file: [ ${model_conf} ]"

    # Convert ${model_conf} to ${model_txt} for [ openwrt-install-amlogic ], Just the first 8 columns.
    cat ${model_conf} |
        sed -e 's/NULL/NA/g' -e 's/[ ][ ]*//g' |
        grep -E "^[^#ar].*" |
        awk -F':' '{if ($6 != "NA") $6 = "/lib/u-boot/"$6; if ($7 != "NA") $7 = "/lib/u-boot/"$7; NF = 12; print}' OFS=':' \
            >${model_txt}

    # Get a list of build devices
    if [[ "${make_board}" == "all" ]]; then
        board_list=":(yes)"
        make_openwrt=($(
            clean_model_conf |
                grep -E "^.*:yes$" | awk -F':' '{print $14}' |
                sort -u | xargs
        ))
    elif [[ "${make_board}" =~ ^(amlogic|rockchip|allwinner)([0-9]+_[0-9]+|[0-9]+)?$ ]]; then
        # Get the platform name and range, such as [ amlogic50 ], [ rockchip50_100 ], etc.
        # name is [ amlogic ], [ rockchip ], [ allwinner ], range is [ 50 ], [ 50_100 ], etc.
        # amlogic50 -> platform_name=amlogic, platform_range=50, rockchip50_100 -> platform_name=rockchip, platform_range=50_100
        platform_name="${BASH_REMATCH[1]}"
        platform_range="${BASH_REMATCH[2]}"
        make_openwrt=($(
            clean_model_conf |
                grep -E "^.*:${platform_name}:.*:yes$" | awk -F':' '{print $14}' |
                sort -u | xargs
        ))
        # Slice by range if specified, such as [ amlogic50 ], [ rockchip50_100 ], etc.
        if [[ "${platform_range}" =~ ^([0-9]+)_([0-9]+)$ ]]; then
            make_openwrt=("${make_openwrt[@]:${BASH_REMATCH[1]}:$((BASH_REMATCH[2] - BASH_REMATCH[1]))}")
        elif [[ -n "${platform_range}" ]]; then
            make_openwrt=("${make_openwrt[@]:0:${platform_range}}")
        fi
        board_list=":($(echo ${make_openwrt[@]} | sed -e 's/ /\|/g')):(yes)"
    elif [[ "${make_board}" =~ ^(first|last)([0-9]+)$ ]]; then
        # first<N>: first N boards, last<N>: last N boards
        slice_type="${BASH_REMATCH[1]}"
        slice_num="${BASH_REMATCH[2]}"
        make_openwrt=($(
            clean_model_conf |
                grep -E "^.*:yes$" | awk -F':' '{print $14}' |
                sort -u | xargs
        ))
        [[ "${slice_type}" == "first" ]] && make_openwrt=("${make_openwrt[@]:0:${slice_num}}")
        [[ "${slice_type}" == "last" ]] && make_openwrt=("${make_openwrt[@]: -${slice_num}}")
        board_list=":($(echo ${make_openwrt[@]} | sed -e 's/ /\|/g')):(yes)"
    elif [[ "${make_board}" =~ ^range([0-9]+)_([0-9]+)$ ]]; then
        # range<N>_<M>: boards from index N, count M-N
        range_start="${BASH_REMATCH[1]}"
        range_end="${BASH_REMATCH[2]}"
        make_openwrt=($(
            clean_model_conf |
                grep -E "^.*:yes$" | awk -F':' '{print $14}' |
                sort -u | xargs
        ))
        make_openwrt=("${make_openwrt[@]:${range_start}:$((range_end - range_start))}")
        board_list=":($(echo ${make_openwrt[@]} | sed -e 's/ /\|/g')):(yes)"
    else
        board_list=":($(echo ${make_board} | sed -e 's/_/\|/g')):(yes|no)"
        # Deduplicate while preserving order so [ -b s905x_s905x ] doesn't build twice.
        make_openwrt=($(echo ${make_board} | tr '_' '\n' | awk 'NF && !seen[$0]++'))
    fi
    [[ "${#make_openwrt[@]}" -eq 0 ]] && error_msg "The [ BOARD ] is missing, stop making."

    # Get the kernel array
    kernel_from=($(
        clean_model_conf |
            grep -E "^.*${board_list}$" | awk -F':' '{print $9}' |
            sort -u | xargs
    ))
    [[ "${#kernel_from[@]}" -eq 0 ]] && error_msg "Missing [ KERNEL_TAGS ] configuration, aborting build."
    # Replace custom kernel tags
    [[ -n "${kernel_usage}" ]] && {
        for ((i = 0; i < ${#kernel_from[@]}; i++)); do
            if [[ ${kernel_from[${i}]} == "${default_tags}/"* ]]; then
                kernel_from[${i}]="${kernel_from[${i}]//${default_tags}/${kernel_usage}}"
            fi
        done
    }

    # Convert the kernel_from to the kernel array
    for item in "${kernel_from[@]}"; do
        # Split the key and value
        IFS='/' read -r key value <<<"${item}"

        # Check if the value is "all".
        if [[ "${value}" == "all" ]]; then
            # If the value is "all", assign the value of ${key}_kernel. such as [ stable_kernel, rk3588_kernel, etc. ]
            eval "value=\"\${${key}_kernel[@]}\""
        elif [[ "${value}" =~ ^[1-9]+ ]]; then
            if [[ "${value}" == "5.x.y" ]]; then
                value="${specific_5xy[@]}"
            elif [[ "${value}" == "6.x.y" ]]; then
                value="${specific_6xy[@]}"
            else
                IFS='_' read -ra value <<<"${value}"
                value="${value[@]}"
            fi
        fi

        # If auto_kernel is false, use the value from -k parameter
        if [[ ! "${auto_kernel}" =~ ^(true|yes)$ ]]; then
            if [[ "${#specific_kernel[@]}" -eq 0 ]]; then
                error_msg "Please use the -k parameter to specify the kernel version."
            else
                value="${specific_kernel[@]}"
            fi
        fi

        # Merge the same key values
        if [[ -n "${tags_list[${key}]}" ]]; then
            tags_list[${key}]+=" ${value}"
        else
            tags_list[${key}]="${value}"
        fi
    done

    # Convert the tags_list array to the kernel array (remove duplicates)
    for key in "${!tags_list[@]}"; do
        # Convert the space-separated string to an array and remove duplicates
        read -ra unique_values <<<"$(echo "${tags_list[${key}]}" | tr ' ' '\n' | sort -u | tr '\n' ' ')"
        # Assign the unique values back to the tags_list
        tags_list[${key}]="${unique_values[@]}"
    done

    # Check the kernel tags list
    [[ "${#tags_list[@]}" -eq 0 ]] && error_msg "The kernel tags list is empty, aborting build."
    echo -e "${INFO} The kernel tags list: [ ${!tags_list[@]} ]"

    # Convert kernel repository address to api format
    [[ "${kernel_repo}" =~ ^https: ]] && kernel_repo="$(echo ${kernel_repo} | awk -F'/' '{print $4"/"$5}')"
    kernel_api="https://github.com/${kernel_repo}"
}

find_openwrt() {
    cd "${current_path}"
    echo -e "${STEPS} Searching for OpenWrt rootfs file..."

    # Find whether the OpenWrt file exists
    openwrt_default_file="$(ls ${openwrt_path}/${openwrt_rootfs_file} 2>/dev/null | head -n 1 | awk -F "/" '{print $NF}')"
    if [[ -n "${openwrt_default_file}" ]]; then
        echo -e "${INFO} Found OpenWrt rootfs file: [ ${openwrt_default_file} ]"
    else
        error_msg "No [ ${openwrt_rootfs_file} ] file found in the [ ${openwrt_path} ] directory."
    fi

    # Extract the OpenWrt release information file
    source_release_file="etc/openwrt_release"
    temp_dir="$(mktemp -d)"
    (cd "${temp_dir}" && tar -mxzf "${openwrt_path}/${openwrt_default_file}" "./${source_release_file}" 2>/dev/null)
    # Extract custom release parameters
    [[ -f "${temp_dir}/${source_release_file}" ]] && {
        # Load the OpenWrt release information
        source "${temp_dir}/${source_release_file}"
        # e.g. DISTRIB_SOURCEREPO='github.com/openwrt/openwrt'
        source_repo="${DISTRIB_SOURCEREPO:-""}"
        # e.g. DISTRIB_SOURCECODE='openwrt'
        source_codename="${DISTRIB_SOURCECODE:-""}"
        # e.g. DISTRIB_SOURCEBRANCH='openwrt-24.10'
        source_branch="${DISTRIB_SOURCEBRANCH:-""}"

        # Print the source information
        echo -e "${INFO} The source codename: [ ${source_codename} ], source branch: [ ${source_branch} ], source repository: [ ${source_repo} ]."
    }
    # Remove temporary directory
    rm -rf "${temp_dir}"
}

git_pull_dir() {
    cd "${current_path}"

    # Check git_pull_dir parameters
    git_repo="${1}"
    git_branch="${2}"
    git_path="${3}"
    [[ -n "${git_repo}" && -n "${git_branch}" && -n "${git_path}" ]] || {
        error_msg "Incomplete git_pull_dir parameters: [ ${git_repo}, ${git_branch}, ${git_path} ]"
    }

    # Clone the repository. Retry up to 10 times with 60-second intervals on failure.
    local clone_ok=0
    for i in {1..10}; do
        if git clone --quiet --single-branch --depth=1 --branch="${git_branch}" "${git_repo}" "${git_path}"; then
            clone_ok=1
            break
        fi
        sleep 60
    done
    [[ "${clone_ok}" -eq 1 ]] || error_msg "Failed to clone the [ ${git_repo} ] repository."
}

download_depends() {
    cd "${current_path}"
    echo -e "${STEPS} Downloading dependency files..."

    # Download u-boot files
    uboot_num="$(find "${uboot_path}/rockchip" -mindepth 1 -maxdepth 1 -type d 2>/dev/null | wc -l)"
    if [[ -n "${uboot_num}" && "${uboot_num}" -le "5" ]]; then
        git_tmp_path="$(mktemp -d)"
        git_pull_dir "${uboot_repo}" main "${git_tmp_path}"
        # Move the u-boot files to the storage directory
        mkdir -p "${uboot_path}"
        cp -af --no-preserve=ownership "${git_tmp_path}/u-boot/." "${uboot_path}" ||
            error_msg "OpenWrt: u-boot download failed."
        echo -e "${INFO} OpenWrt: u-boot download completed."
        # Delete temporary files
        rm -rf "${git_tmp_path}"
    else
        echo -e "${INFO} OpenWrt: u-boot files already exist, skipping download."
    fi

    # Download firmware files
    firmware_num="$(find "${firmware_path}" -mindepth 1 -maxdepth 1 -type d 2>/dev/null | wc -l)"
    if [[ -n "${firmware_num}" && "${firmware_num}" -le "5" ]]; then
        git_tmp_path="$(mktemp -d)"
        git_pull_dir "${firmware_repo}" main "${git_tmp_path}"
        # Move the firmware files to the storage directory
        mkdir -p "${firmware_path}"
        cp -af --no-preserve=ownership "${git_tmp_path}/firmware/." "${firmware_path}" ||
            error_msg "OpenWrt: firmware download failed."
        echo -e "${INFO} OpenWrt: firmware download completed."
        # Delete temporary files
        rm -rf "${git_tmp_path}"
    else
        echo -e "${INFO} OpenWrt: firmware files already exist, skipping download."
    fi

    # Download Armbian repository files
    git_tmp_path="$(mktemp -d)"
    git_pull_dir "${depends_repo}" main "${git_tmp_path}"
    # Remove Armbian-specific files from the [ sbin ] directory
    find "${git_tmp_path}" -type d -path "*/platform-files/*/rootfs/usr/sbin" -prune -exec rm -rf {} +
    # Move the platform files to the storage directory
    cp -af --no-preserve=ownership "${git_tmp_path}/build-armbian/armbian-files/platform-files/." "${platform_files}" ||
        error_msg "OpenWrt: platform-files download failed."
    echo -e "${INFO} OpenWrt: platform-files download completed."
    # Move the different files to the storage directory
    cp -af --no-preserve=ownership "${git_tmp_path}/build-armbian/armbian-files/different-files/." "${different_files}" ||
        error_msg "OpenWrt: different-files download failed."
    echo -e "${INFO} OpenWrt: different-files download completed."
    # Move the balethirq files to the storage directory
    cp -f --no-preserve=ownership "${git_tmp_path}/build-armbian/armbian-files/common-files/usr/sbin/balethirq.pl" "${common_files}/usr/sbin" &&
        cp -f --no-preserve=ownership "${git_tmp_path}/build-armbian/armbian-files/common-files/etc/balance_irq" "${common_files}/etc" ||
        error_msg "OpenWrt: balethirq download failed."
    echo -e "${INFO} OpenWrt: balethirq download completed."
    # Delete temporary files
    rm -rf "${git_tmp_path}"

    # Download luci-app-amlogic install/update and other related files
    git_tmp_path="$(mktemp -d)"
    git_pull_dir "${script_repo}" main "${git_tmp_path}"
    # Move the sbin files to the storage directory
    cp -af --no-preserve=ownership "${git_tmp_path}/luci-app-amlogic/root/usr/sbin/." "${common_files}/usr/sbin" ||
        error_msg "luci-app-amlogic: sbin download failed."
    echo -e "${INFO} luci-app-amlogic: sbin download completed."
    find "${common_files}/usr/sbin/" -name "openwrt-*" -exec chmod +x {} + 2>/dev/null
    # Move the share files to the storage directory
    mkdir -p "${common_files}/usr/share/amlogic"
    cp -af --no-preserve=ownership "${git_tmp_path}/luci-app-amlogic/root/usr/share/amlogic/." "${common_files}/usr/share/amlogic" ||
        error_msg "luci-app-amlogic: share download failed."
    echo -e "${INFO} luci-app-amlogic: share download completed."
    find "${common_files}/usr/share/amlogic/" -type f -exec chmod +x {} + 2>/dev/null
    # Delete temporary files
    rm -rf "${git_tmp_path}"
}

query_kernel() {
    echo -e "${STEPS} Querying latest kernel versions..."

    # Check the version on the kernel repository
    x="1"
    for key in "${!tags_list[@]}"; do
        {
            # Query the name of the latest kernel version
            tmp_arr_kernels=()
            down_kernel_list=(${tags_list[${key}]})
            i=1
            for kernel_var in "${down_kernel_list[@]}"; do
                echo -e "${INFO} (${x}.${i}) Querying latest kernel version for [ ${key} - ${kernel_var} ]"

                # Identify the kernel <VERSION> and <PATCHLEVEL>, such as [ 6.1 ]
                kernel_verpatch="$(echo ${kernel_var} | awk -F '.' '{print $1"."$2}')"

                # Query the latest kernel version
                latest_version="$(
                    curl -fsSL \
                        ${kernel_api}/releases/expanded_assets/kernel_${key} |
                        grep -oP "${kernel_verpatch}\.[0-9]+(?=\.tar\.gz)" |
                        sort -urV | head -n 1
                )"

                if [[ -n "${latest_version}" ]]; then
                    tmp_arr_kernels[${i}]="${latest_version}"
                else
                    tmp_arr_kernels[${i}]="${kernel_var}"
                fi

                echo -e "${INFO} (${x}.${i}) [ ${key} - ${tmp_arr_kernels[$i]} ] is the latest kernel version. \n"

                ((i++))
            done

            # Assign the latest kernel version to the array
            tags_list[${key}]="${tmp_arr_kernels[@]}"

            ((x++))
        }
    done
}

check_kernel() {
    [[ -n "${1}" ]] && check_path="${1}" || error_msg "Invalid kernel path to check."
    check_files=($(awk '{print $2}' "${check_path}/sha256sums"))
    for cf in "${check_files[@]}"; do
        {
            # Check if file exists
            [[ -s "${check_path}/${cf}" ]] || error_msg "The [ ${cf} ] file is missing."
            # Check if the file sha256sum is correct (exact filename match, no substring confusion)
            tmp_sha256sum="$(sha256sum "${check_path}/${cf}" | awk '{print $1}')"
            tmp_checkcode="$(awk -v f="${cf}" '$2==f {print $1}' "${check_path}/sha256sums")"
            [[ "${tmp_sha256sum}" == "${tmp_checkcode}" ]] || error_msg "[ ${cf} ]: sha256sum verification failed."
        }
    done
    echo -e "${INFO} All [ ${#check_files[@]} ] kernel files passed SHA256 integrity verification.\n"
}

download_kernel() {
    cd "${current_path}"
    echo -e "${STEPS} Downloading kernel files..."

    x="1"
    for key in "${!tags_list[@]}"; do
        {
            down_kernel_list=(${tags_list[${key}]})
            # Download the kernel to the storage directory
            i="1"
            for kernel_var in "${down_kernel_list[@]}"; do
                if [[ ! -d "${kernel_path}/${key}/${kernel_var}" ]]; then
                    kernel_down_from="https://github.com/${kernel_repo}/releases/download/kernel_${key}/${kernel_var}.tar.gz"
                    echo -e "${INFO} (${x}.${i}) [ ${key} - ${kernel_var} ] Downloading kernel from [ ${kernel_down_from} ]"

                    # Download the kernel files. Retry up to 10 times with 60-second intervals on failure.
                    [[ -d "${kernel_path}/${key}" ]] || mkdir -p "${kernel_path}/${key}"
                    local _curl_ok=0
                    for t in {1..10}; do
                        if curl -fsSL "${kernel_down_from}" -o "${kernel_path}/${key}/${kernel_var}.tar.gz"; then
                            _curl_ok=1
                            break
                        fi
                        sleep 60
                    done
                    [[ "${_curl_ok}" -eq 1 ]] || error_msg "Failed to download the kernel files."

                    # Extract the kernel files
                    tar -mxzf "${kernel_path}/${key}/${kernel_var}.tar.gz" -C "${kernel_path}/${key}" ||
                        error_msg "[ ${kernel_var} ] kernel archive extraction failed."
                else
                    echo -e "${INFO} (${x}.${i}) [ ${key} - ${kernel_var} ] Kernel already exists locally."
                fi

                # If the kernel contains the sha256sums file, check the files integrity
                [[ -f "${kernel_path}/${key}/${kernel_var}/sha256sums" ]] && check_kernel "${kernel_path}/${key}/${kernel_var}"

                ((i++))
            done

            # Delete kernel download temporary files
            rm -f "${kernel_path}/${key}"/*.tar.gz
            sync

            ((x++))
        }
    done
}

confirm_version() {
    cd "${current_path}"

    # Columns of ${model_conf}:
    # 1.ID  2.MODEL  3.SOC  4.FDTFILE  5.UBOOT_OVERLOAD  6.MAINLINE_UBOOT  7.BOOTLOADER_IMG  8.DESCRIPTION
    # 9.KERNEL_TAGS  10.PLATFORM  11.FAMILY  12.BOOT_CONF  13.CONTRIBUTORS  14.BOARD  15.BUILD
    # Column 5, called <UBOOT_OVERLOAD> in Amlogic, <TRUST_IMG> in Rockchip, Not used in Allwinner.

    # Find [ the first ] configuration with [ matching BOARD name ] and [ BUILD as yes ] in ${model_conf}
    board_conf="$(
        clean_model_conf |
            grep -E "^.*:${board}:(yes|no)$" |
            head -n 1
    )"
    [[ -n "${board_conf}" ]] || error_msg "[ ${board} ] configuration not found!"

    # Get device settings options
    MODEL_ID="$(echo ${board_conf} | awk -F':' '{print $1}')"
    MODEL_NAME="$(echo ${board_conf} | awk -F':' '{print $2}')"
    SOC="$(echo ${board_conf} | awk -F':' '{print $3}')"
    FDTFILE="$(echo ${board_conf} | awk -F':' '{print $4}')"
    UBOOT_OVERLOAD="$(echo ${board_conf} | awk -F':' '{print $5}')"
    TRUST_IMG="${UBOOT_OVERLOAD}"
    MAINLINE_UBOOT="$(echo ${board_conf} | awk -F':' '{print $6}')"
    BOOTLOADER_IMG="$(echo ${board_conf} | awk -F':' '{print $7}')"
    KERNEL_TAGS="$(echo ${board_conf} | awk -F':' '{print $9}')"
    PLATFORM="$(echo ${board_conf} | awk -F':' '{print $10}')"
    FAMILY="$(echo ${board_conf} | awk -F':' '{print $11}')"
    BOOT_CONF="$(echo ${board_conf} | awk -F':' '{print $12}')"
    CONTRIBUTORS="$(echo ${board_conf} | awk -F':' '{print $13}')"

    # Check whether the key parameters are correct
    [[ -n "${PLATFORM}" ]] || error_msg "Invalid PLATFORM parameter: [ ${PLATFORM} ]"
    # Set supported platform name
    support_platform=("amlogic" "rockchip" "allwinner")
    [[ -n "$(echo "${support_platform[@]}" | grep -w "${PLATFORM}")" ]] || error_msg "[ ${PLATFORM} ] platform is not supported."

    # Add u-boot files record information
    [[ -n "${MAINLINE_UBOOT}" ]] && RECORD_MAINLINE_UBOOT="/lib/u-boot/${MAINLINE_UBOOT}" || RECORD_MAINLINE_UBOOT=""
    [[ -n "${BOOTLOADER_IMG}" ]] && RECORD_BOOTLOADER_IMG="/lib/u-boot/${BOOTLOADER_IMG}" || RECORD_BOOTLOADER_IMG=""
    [[ -n "${TRUST_IMG}" ]] && RECORD_TRUST_IMG="/lib/u-boot/${TRUST_IMG}" || RECORD_TRUST_IMG=""
    # Set the Amlogic u-boot series
    family_rename="${FAMILY//-/_}"
    eval "amlogic_uboot=(\${uboot_${family_rename}[@]})"

    # Get the kernel tags and version
    conf_kernel_tags="${KERNEL_TAGS%%/*}"
    conf_kernel_list="${KERNEL_TAGS##*/}"
    # Replace the default kernel tags with the custom kernel tags
    [[ -n "${kernel_usage}" && "${conf_kernel_tags}" == "${default_tags}" ]] && conf_kernel_tags="${kernel_usage}"
    # Check the kernel tags and version
    [[ -z "${conf_kernel_tags}" ]] && error_msg "The [ ${KERNEL_TAGS} ] is missing tags part."
    [[ -z "${conf_kernel_list}" ]] && error_msg "The [ ${KERNEL_TAGS} ] is missing list part."

    # Find the kernel list defined in the model database
    model_kernel=()
    if [[ "${conf_kernel_list}" == "all" ]]; then
        eval "model_kernel=(\"\${${conf_kernel_tags}_kernel[@]}\")"
        model_kernel=($(echo "${model_kernel[@]}" | xargs -n1 | sed -E 's/^([0-9]+\.[0-9]+)(\.[a-z0-9]+)?$/\1.[0-9]+/'))
    else
        # Convert the string into an array, using "_" as the delimiter
        IFS='_' read -ra conf_kernel_list <<<"${conf_kernel_list}"
        model_kernel=($(echo "${conf_kernel_list[@]}" | xargs -n1 | sed -E 's/^([0-9]+\.[0-9]+)(\.[a-z0-9]+)?$/\1.[0-9]+/'))
    fi
    # Check the kernel list
    [[ "${#model_kernel[@]}" -eq 0 ]] && error_msg "The kernel list is empty for [ ${board} ]"

    # Find the kernel version that matches the custom version
    build_kernel=()
    latest_kernel=(${tags_list[${conf_kernel_tags}]})
    for ck in "${model_kernel[@]}"; do
        for lk in "${latest_kernel[@]}"; do
            [[ "${lk}" =~ ^${ck}$ ]] && build_kernel+=("${lk}")
        done
    done
    # Check the kernel version
    [[ "${#build_kernel[@]}" -eq 0 ]] && error_msg "The kernel list is invalid for [ ${board} ]"
}

make_image() {
    process_msg "(1/6) Creating OpenWrt image."
    cd "${current_path}"

    # Set Armbian image file parameters
    [[ "${PLATFORM}" == "amlogic" ]] && {
        skip_mb="4"
        partition_table_type="msdos"
        bootfs_type="fat32"
    }
    [[ "${PLATFORM}" == "rockchip" ]] && {
        skip_mb="16"
        partition_table_type="gpt"
        bootfs_type="ext4"
    }
    [[ "${PLATFORM}" == "allwinner" ]] && {
        skip_mb="16"
        partition_table_type="msdos"
        bootfs_type="fat32"
    }

    # Special procedures for board-specific customization
    # Reset default parameters
    write_board_file="no"
    adjust_kernel_files="no"
    # Check the personalized settings for this board
    board_release="${different_files}/${board}/rootfs/${board_release_file}"
    [[ -f "${board_release}" ]] && source "${board_release}"

    # echo -e "${INFO} The [ ${board} ] OpenWrt image partition status: [ skip:${skip_mb} / boot:${boot_mb} / rootfs:${root_mb} ] MiB."

    # Check output directory
    [[ -d "${out_path}" ]] || mkdir -p "${out_path}"
    # Add the source codename to the OpenWrt filename
    [[ "${source_codename}" == "openwrt" ]] && openwrt_alias="official" || openwrt_alias="${source_codename}"
    [[ -n "${openwrt_alias}" ]] && openwrt_alias+="_" || openwrt_alias=""
    # Set OpenWrt image filename
    openwrt_filename="openwrt_${openwrt_alias}${PLATFORM}_${board}_k${kernel}_$(date +"%Y.%m.%d").img"
    build_image_file="${out_path}/${openwrt_filename}"
    rm -f "${build_image_file}"

    IMG_SIZE="$((skip_mb + boot_mb + root_mb))"
    truncate -s ${IMG_SIZE}M "${build_image_file}" >/dev/null 2>&1

    parted -s "${build_image_file}" mklabel ${partition_table_type} 2>/dev/null
    parted -s "${build_image_file}" mkpart primary ${bootfs_type} $((skip_mb))MiB $((skip_mb + boot_mb - 1))MiB 2>/dev/null
    parted -s "${build_image_file}" mkpart primary btrfs $((skip_mb + boot_mb))MiB 100% 2>/dev/null

    # Mount the OpenWrt image file
    loop_new="$(losetup -P -f --show "${build_image_file}")"
    [[ -n "${loop_new}" ]] || error_msg "losetup ${build_image_file} failed."

    # Confirm BOOT_UUID
    BOOT_UUID="$(cat /proc/sys/kernel/random/uuid)"
    [[ -z "${BOOT_UUID}" ]] && BOOT_UUID="$(uuidgen)"
    [[ -z "${BOOT_UUID}" ]] && error_msg "UUID generation failed, cannot continue."
    # Confirm ROOTFS_UUID
    ROOTFS_UUID="$(cat /proc/sys/kernel/random/uuid)"
    [[ -z "${ROOTFS_UUID}" ]] && ROOTFS_UUID="$(uuidgen)"
    [[ -z "${ROOTFS_UUID}" ]] && error_msg "UUID generation failed, cannot continue."

    # Format bootfs partition
    if [[ "${bootfs_type}" == "fat32" ]]; then
        mkfs.vfat -F 32 -n "BOOT" ${loop_new}p1 >/dev/null 2>&1
    else
        mkfs.ext4 -F -q -U ${BOOT_UUID} -L "BOOT" -b 4k -m 0 ${loop_new}p1 >/dev/null 2>&1
    fi

    # Format rootfs partition
    mkfs.btrfs -f -U ${ROOTFS_UUID} -L "ROOTFS" -m single ${loop_new}p2 >/dev/null 2>&1

    # Write the specific bootloader for [ Amlogic ] boxes
    [[ "${PLATFORM}" == "amlogic" ]] && {
        bootloader_path="${uboot_path}/${PLATFORM}/bootloader"
        if [[ -n "${MAINLINE_UBOOT}" && -f "${bootloader_path}/${MAINLINE_UBOOT}" ]]; then
            dd if="${bootloader_path}/${MAINLINE_UBOOT}" of="${loop_new}" conv=fsync bs=1 count=444 2>/dev/null
            dd if="${bootloader_path}/${MAINLINE_UBOOT}" of="${loop_new}" conv=fsync bs=512 skip=1 seek=1 2>/dev/null
            #echo -e "${INFO} 01. For [ ${board} ] write bootloader: ${MAINLINE_UBOOT}"
        elif [[ -n "${BOOTLOADER_IMG}" && -f "${bootloader_path}/${BOOTLOADER_IMG}" ]]; then
            dd if="${bootloader_path}/${BOOTLOADER_IMG}" of="${loop_new}" conv=fsync bs=1 count=444 2>/dev/null
            dd if="${bootloader_path}/${BOOTLOADER_IMG}" of="${loop_new}" conv=fsync bs=512 skip=1 seek=1 2>/dev/null
            #echo -e "${INFO} 02. For [ ${board} ] write bootloader: ${BOOTLOADER_IMG}"
        fi
    }

    # Write the specific bootloader for [ Rockchip ] boxes
    [[ "${PLATFORM}" == "rockchip" ]] && {
        bootloader_path="${uboot_path}/${PLATFORM}/${board}"
        if [[ -n "${BOOTLOADER_IMG}" && -f "${bootloader_path}/${BOOTLOADER_IMG}" ]] &&
            [[ -n "${MAINLINE_UBOOT}" && -f "${bootloader_path}/${MAINLINE_UBOOT}" ]] &&
            [[ -n "${TRUST_IMG}" && -f "${bootloader_path}/${TRUST_IMG}" ]]; then
            dd if="${bootloader_path}/${BOOTLOADER_IMG}" of="${loop_new}" conv=fsync,notrunc bs=512 seek=64 2>/dev/null
            dd if="${bootloader_path}/${MAINLINE_UBOOT}" of="${loop_new}" conv=fsync,notrunc bs=512 seek=16384 2>/dev/null
            dd if="${bootloader_path}/${TRUST_IMG}" of="${loop_new}" conv=fsync,notrunc bs=512 seek=24576 2>/dev/null
            #echo -e "${INFO} 01. For [ ${board} ] write bootloader: ${TRUST_IMG}"
        elif [[ -n "${BOOTLOADER_IMG}" && -f "${bootloader_path}/${BOOTLOADER_IMG}" ]] &&
            [[ -n "${MAINLINE_UBOOT}" && -f "${bootloader_path}/${MAINLINE_UBOOT}" ]]; then
            dd if="${bootloader_path}/${BOOTLOADER_IMG}" of="${loop_new}" conv=fsync,notrunc bs=512 seek=64 2>/dev/null
            dd if="${bootloader_path}/${MAINLINE_UBOOT}" of="${loop_new}" conv=fsync,notrunc bs=512 seek=16384 2>/dev/null
            #echo -e "${INFO} 02. For [ ${board} ] write bootloader: ${MAINLINE_UBOOT}"
        elif [[ "${BOOTLOADER_IMG}" == "u-boot-rockchip.bin" && -f "${bootloader_path}/${BOOTLOADER_IMG}" ]]; then
            dd if="${bootloader_path}/${BOOTLOADER_IMG}" of="${loop_new}" conv=fsync,notrunc bs=512 seek=64 2>/dev/null
            #echo -e "${INFO} 03. For [ ${board} ] write bootloader: ${BOOTLOADER_IMG}"
        elif [[ -n "${BOOTLOADER_IMG}" && -f "${bootloader_path}/${BOOTLOADER_IMG}" ]]; then
            dd if="${bootloader_path}/${BOOTLOADER_IMG}" of="${loop_new}" conv=fsync,notrunc bs=512 skip=64 seek=64 2>/dev/null
            #echo -e "${INFO} 04. For [ ${board} ] write bootloader: ${BOOTLOADER_IMG}"
        fi
    }

    # Write the specific bootloader for [ Allwinner ] boxes
    [[ "${PLATFORM}" == "allwinner" ]] && {
        bootloader_path="${uboot_path}/${PLATFORM}/${board}"
        if [[ -n "${BOOTLOADER_IMG}" && -f "${bootloader_path}/${BOOTLOADER_IMG}" ]] &&
            [[ -n "${MAINLINE_UBOOT}" && -f "${bootloader_path}/${MAINLINE_UBOOT}" ]]; then
            dd if="${bootloader_path}/${BOOTLOADER_IMG}" of="${loop_new}" conv=fsync,notrunc bs=8k seek=1 2>/dev/null
            dd if="${bootloader_path}/${MAINLINE_UBOOT}" of="${loop_new}" conv=fsync,notrunc bs=8k seek=5 2>/dev/null
            #echo -e "${INFO} 01. For [ ${board} ] write bootloader: ${MAINLINE_UBOOT}"
        elif [[ -n "${BOOTLOADER_IMG}" && -f "${bootloader_path}/${BOOTLOADER_IMG}" ]]; then
            dd if="${bootloader_path}/${BOOTLOADER_IMG}" of="${loop_new}" conv=fsync,notrunc bs=8k seek=1 2>/dev/null
            #echo -e "${INFO} 02. For [ ${board} ] write bootloader: ${BOOTLOADER_IMG}"
        fi
    }

    # Special procedures for flashing specific boards
    [[ "${write_board_file}" == "yes" ]] && write_board_bootloader
}

extract_openwrt() {
    process_msg "(2/6) Extracting OpenWrt files."
    cd "${current_path}"

    # Create a dual-partition general directory
    tag_bootfs="${tmp_path}/${kernel}/${board}/bootfs"
    tag_rootfs="${tmp_path}/${kernel}/${board}/rootfs"
    mkdir -p "${tag_bootfs}" "${tag_rootfs}"
    chown root:root "${tag_bootfs}" "${tag_rootfs}"

    # Mount bootfs
    if [[ "${bootfs_type}" == "fat32" ]]; then
        mount_try vfat "${loop_new}p1" "${tag_bootfs}"
    else
        mount_try ext4 "${loop_new}p1" "${tag_bootfs}"
    fi

    # Mount rootfs
    mount_try btrfs "${loop_new}p2" "${tag_rootfs}"

    # Create snapshot directory
    btrfs subvolume create "${tag_rootfs}/etc" >/dev/null 2>&1

    # Unzip the OpenWrt rootfs file
    tar -mxzf "${openwrt_path}/${openwrt_default_file}" -C "${tag_rootfs}"
    [[ -n "${tag_rootfs}" && -d "${tag_rootfs}/lib/modules" ]] && rm -rf "${tag_rootfs}/lib/modules"/*
    rm -f "${tag_rootfs}/rom/sbin/firstboot"

    # Copy the common files
    [[ -d "${common_files}" ]] && cp -af --no-preserve=ownership "${common_files}/." "${tag_rootfs}"

    # Copy the platform files
    platform_bootfs="${platform_files}/${PLATFORM}/bootfs"
    platform_rootfs="${platform_files}/${PLATFORM}/rootfs"
    [[ -d "${platform_bootfs}" ]] && cp -rf "${platform_bootfs}/." "${tag_bootfs}"
    [[ -d "${platform_rootfs}" ]] && cp -af --no-preserve=ownership "${platform_rootfs}/." "${tag_rootfs}"

    # Copy the different files
    different_bootfs="${different_files}/${board}/bootfs"
    different_rootfs="${different_files}/${board}/rootfs"
    [[ -d "${different_bootfs}" ]] && cp -rf "${different_bootfs}/." "${tag_bootfs}"
    [[ -d "${different_rootfs}" ]] && cp -af --no-preserve=ownership "${different_rootfs}/." "${tag_rootfs}"

    # Copy the bootloader files
    [[ -d "${tag_rootfs}/lib/u-boot" ]] || mkdir -p "${tag_rootfs}/lib/u-boot"
    [[ -n "${tag_rootfs}" && -d "${tag_rootfs}/lib/u-boot" ]] && rm -rf "${tag_rootfs}/lib/u-boot"/*
    [[ -d "${bootloader_path}" ]] && cp -af --no-preserve=ownership "${bootloader_path}/." "${tag_rootfs}/lib/u-boot"

    # Copy the Amlogic overload files
    [[ "${PLATFORM}" == "amlogic" ]] && {
        for au in "${amlogic_uboot[@]}"; do
            if [[ -f "${uboot_path}/${PLATFORM}/overload/u-boot-${au}" ]]; then
                cp -f "${uboot_path}/${PLATFORM}/overload/u-boot-${au}" "${tag_bootfs}"
            else
                error_msg "The [ u-boot-${au} ] file is missing in the [ ${uboot_path}/${PLATFORM}/overload ] directory."
            fi
        done
    }

    # Remove the .git directories
    rm -rf $(find "${tmp_path}" -type d -name '.git')
}

replace_kernel() {
    process_msg "(3/6) Replacing kernel files."
    cd "${current_path}"

    # Determine kernel filename based on version
    kernel_boot="$(ls ${kernel_path}/${conf_kernel_tags}/${kernel}/boot-${kernel}*.tar.gz 2>/dev/null | head -n 1)"
    kernel_name="${kernel_boot##*/}" && kernel_name="${kernel_name:5:-7}"
    [[ -n "${kernel_name}" ]] || error_msg "Missing kernel files for [ ${kernel} ]."
    kernel_dtb="${kernel_path}/${conf_kernel_tags}/${kernel}/dtb-${PLATFORM}-${kernel_name}.tar.gz"
    kernel_modules="${kernel_path}/${conf_kernel_tags}/${kernel}/modules-${kernel_name}.tar.gz"
    [[ -s "${kernel_boot}" && -s "${kernel_dtb}" && -s "${kernel_modules}" ]] || error_msg "Required kernel archives are missing."

    # 01. For /boot five files
    tar -mxzf ${kernel_boot} -C ${tag_bootfs}
    [[ "${PLATFORM}" == "allwinner" ]] && (cd ${tag_bootfs} && cp -f uInitrd-${kernel_name} uInitrd && cp -f vmlinuz-${kernel_name} Image)
    [[ "${PLATFORM}" == "amlogic" ]] && (cd ${tag_bootfs} && cp -f uInitrd-${kernel_name} uInitrd && cp -f vmlinuz-${kernel_name} zImage)
    [[ "${PLATFORM}" == "rockchip" ]] && (cd ${tag_bootfs} && ln -sf uInitrd-${kernel_name} uInitrd && ln -sf vmlinuz-${kernel_name} Image)
    [[ "$(ls ${tag_bootfs}/*${kernel_name} -l 2>/dev/null | grep "^-" | wc -l)" -ge "2" ]] || error_msg "The /boot files is missing."
    [[ "${PLATFORM}" == "amlogic" ]] && get_textoffset "${tag_bootfs}/zImage"

    # 02. For /boot/dtb/${PLATFORM}/*
    [[ -d "${tag_bootfs}/dtb/${PLATFORM}" ]] || mkdir -p ${tag_bootfs}/dtb/${PLATFORM}
    tar -mxzf ${kernel_dtb} -C ${tag_bootfs}/dtb/${PLATFORM}
    [[ "${PLATFORM}" == "rockchip" ]] && ln -sf dtb ${tag_bootfs}/dtb-${kernel_name}
    [[ "$(ls ${tag_bootfs}/dtb/${PLATFORM} -l 2>/dev/null | grep "^-" | wc -l)" -ge "2" ]] || error_msg "/boot/dtb/${PLATFORM} files is missing."

    # 03. For /lib/modules/${kernel_name}
    tar -mxzf ${kernel_modules} -C ${tag_rootfs}/lib/modules
    (cd ${tag_rootfs}/lib/modules/${kernel_name}/ && rm -f build source *.ko 2>/dev/null && find ./ -type f -name '*.ko' -exec ln -s {} ./ \;)
    [[ "$(ls ${tag_rootfs}/lib/modules/${kernel_name} -l 2>/dev/null | grep "^d" | wc -l)" -eq "1" ]] || error_msg "/usr/lib/modules kernel folder is missing."

    # Special procedures for flashing specific boards
    [[ "${adjust_kernel_files}" == "yes" ]] && adjust_kernel_files_cmd
}

refactor_bootfs() {
    process_msg "(4/6) Configuring bootfs files."
    cd "${tag_bootfs}"

    # Process Amlogic series boot partition files
    [[ "${PLATFORM}" == "amlogic" && "${need_overload}" == "yes" ]] && {
        # Add u-boot.ext for Amlogic 5.10 kernel
        if [[ -n "${UBOOT_OVERLOAD}" && -f "${UBOOT_OVERLOAD}" ]]; then
            cp -f "${UBOOT_OVERLOAD}" u-boot.ext
            chmod +x u-boot.ext
        elif [[ -z "${UBOOT_OVERLOAD}" || ! -f "${UBOOT_OVERLOAD}" ]]; then
            error_msg "${board} does not support kernel ${kernel}, required u-boot overload file is missing."
        fi
    }

    # Set uEnv.txt & extlinux.conf mount parameters
    uenv_rootdev="UUID=${ROOTFS_UUID} rootflags=compress=zstd:6 rw rootwait rootfstype=btrfs"
    # Set armbianEnv.txt mount parameters
    armbianenv_rootdev="UUID=${ROOTFS_UUID}"
    armbianenv_rootflags="compress=zstd:6"

    # Edit the uEnv.txt
    uenv_conf_file="uEnv.txt"
    [[ -f "${uenv_conf_file}" ]] && {
        sed -i \
            -e "s|LABEL=ROOTFS|${uenv_rootdev}|g" \
            -e "s|meson.*.dtb|${FDTFILE}|g" \
            -e "s|sun.*.dtb|${FDTFILE}|g" \
            -e "s|rk.*.dtb|${FDTFILE}|g" \
            "${uenv_conf_file}"
    }

    # Add an alternate file (/boot/extlinux/extlinux.conf)
    boot_extlinux_file="extlinux/extlinux.conf.bak"
    rename_extlinux_file="extlinux/extlinux.conf"
    [[ -f "${boot_extlinux_file}" ]] && {
        sed -i \
            -e "s|LABEL=ROOTFS|${uenv_rootdev}|g" \
            -e "s|meson.*.dtb|${FDTFILE}|g" \
            -e "s|sun.*.dtb|${FDTFILE}|g" \
            -e "s|rk.*.dtb|${FDTFILE}|g" \
            "${boot_extlinux_file}"
        # If needed, such as t95z(s905x), rename delete .bak
        [[ "${BOOT_CONF}" == "extlinux.conf" ]] && mv -f "${boot_extlinux_file}" "${rename_extlinux_file}"
    }

    # Edit the armbianEnv.txt
    armbianenv_conf_file="armbianEnv.txt"
    [[ -f "${armbianenv_conf_file}" ]] && {
        sed -i \
            -e "s|\\(fdtfile=.*\\/\\)[^/]*$|\\1${FDTFILE}|g" \
            -e "s|^rootdev=.*|rootdev=${armbianenv_rootdev}|g" \
            -e "s|^rootfstype=.*|rootfstype=btrfs|g" \
            -e "s|^rootflags=.*|rootflags=${armbianenv_rootflags}|g" \
            -e "s|^overlay_prefix=.*|overlay_prefix=${FAMILY}|g" \
            "${armbianenv_conf_file}"
    }

    # Check device configuration files
    [[ -f "${uenv_conf_file}" || -f "${rename_extlinux_file}" || -f "${armbianenv_conf_file}" ]] || error_msg "Missing boot configuration file [ /boot/*Env.txt ]."
}

refactor_rootfs() {
    process_msg "(5/6) Configuring rootfs files."
    cd "${tag_rootfs}"

    # Add directory
    mkdir -p .reserved boot run

    # Set default IP address
    [[ "${openwrt_ip}" != "192.168.1.1" && -f "bin/config_generate" ]] && {
        sed -i "/lan) ipad=\${ipaddr:-/s/\${ipaddr:-\"[^\"]*\"}/\${ipaddr:-\"${openwrt_ip}\"}/" bin/config_generate
    }

    # Edit fstab
    [[ -f "etc/fstab" && -f "etc/config/fstab" ]] || error_msg "The [ fstab ] files do not exist."
    sed -i "s|LABEL=ROOTFS|UUID=${ROOTFS_UUID}|g" etc/fstab
    sed -i "s|option label 'ROOTFS'|option uuid '${ROOTFS_UUID}'|g" etc/config/fstab

    # Set the OpenWrt download tags for luci-app-amlogic
    [[ -n "${source_codename}" ]] && tags_str="_${source_codename}" || tags_str=""
    [[ -n "${source_branch}" ]] && tags_str+="_${source_branch}_"
    [[ -n "${tags_str}" ]] && sed -i "s|option amlogic_firmware_tag.*|option amlogic_firmware_tag '${tags_str}'|g" etc/config/amlogic
    # Set the kernel download tags for luci-app-amlogic
    sed -i "s|option amlogic_kernel_tags.*|option amlogic_kernel_tags 'kernel_${conf_kernel_tags}'|g" etc/config/amlogic
    # Set the OpenWrt and kernel download branches for luci-app-amlogic
    kernel_patchlevel="$(echo ${kernel} | awk -F '.' '{print $1"."$2}')"
    sed -i "s|option amlogic_kernel_branch.*|option amlogic_kernel_branch '${kernel_patchlevel}'|g" etc/config/amlogic

    # Modify the default script to [ bash ] for [ cpustat ]
    [[ -x "bin/bash" ]] && {
        sed -i "s/\/bin\/ash/\/bin\/bash/" etc/passwd
        sed -i "s/\/bin\/ash/\/bin\/bash/" usr/libexec/login.sh
    }

    # Turn off hw_flow by default
    [[ -f "etc/config/turboacc" ]] && {
        sed -i "s|option hw_flow.*|option hw_flow '0'|g" etc/config/turboacc
        sed -i "s|option sw_flow.*|option sw_flow '0'|g" etc/config/turboacc
    }

    # Add custom startup script
    custom_startup_script="etc/custom_service/start_service.sh"
    [[ -x "${custom_startup_script}" && -f "etc/rc.local" ]] && {
        sed -i '/^exit 0/i\bash /etc/custom_service/start_service.sh &' etc/rc.local
    }

    # Modify the cpu mode to schedutil
    [[ -f "etc/config/cpufreq" ]] && sed -i "s|ondemand|schedutil|" etc/config/cpufreq

    # Turn off speed limit by default
    [[ -f "etc/config/nft-qos" ]] && sed -i "s|option limit_enable.*|option limit_enable '0'|g" etc/config/nft-qos

    # Disable the OpenSSL acceleration engine
    [[ -f "etc/ssl/openssl.cnf" ]] && sed -i "s|^engines = engines_sect|#engines = engines_sect|g" etc/ssl/openssl.cnf

    # Add USB and wireless network drivers
    [[ -f "etc/modules.d/usb-net-rtl8150" ]] || echo "rtl8150" >etc/modules.d/usb-net-rtl8150
    # USB RTL8152/8153/8156 network card Driver
    [[ -f "etc/modules.d/usb-net-rtl8152" ]] || echo "r8152" >etc/modules.d/usb-net-rtl8152
    # USB AX88179 network card Driver
    [[ -f "etc/modules.d/usb-net-asix-ax88179" ]] || echo "ax88179_178a" >etc/modules.d/usb-net-asix-ax88179
    # brcmfmac built-in wireless network card Driver
    echo "brcmfmac" >etc/modules.d/brcmfmac
    echo "brcmutil" >etc/modules.d/brcmutil
    echo "bcmdhd" >etc/modules.d/bcmdhd
    # USB Realtek RTL8188EU Wireless LAN Driver
    echo "r8188eu" >etc/modules.d/rtl8188eu
    # Realtek RTL8189FS Wireless LAN Driver
    echo "8189fs" >etc/modules.d/8189fs
    # Realtek RTL8188FU Wireless LAN Driver
    echo "rtl8188fu" >etc/modules.d/rtl8188fu
    # Realtek RTL8822CS Wireless LAN Driver
    echo "rtw88_8822cs" >etc/modules.d/rtw88_8822cs
    # USB Ralink Wireless LAN Driver
    echo "rt2500usb" >etc/modules.d/rt2500-usb
    echo "rt2800usb" >etc/modules.d/rt2800-usb
    echo "rt2x00usb" >etc/modules.d/rt2x00-usb
    # USB Mediatek Wireless LAN Driver
    echo "mt7601u" >etc/modules.d/mt7601u
    echo "mt7663u" >etc/modules.d/mt7663u
    echo "mt76x0u" >etc/modules.d/mt76x0u
    echo "mt76x2u" >etc/modules.d/mt76x2u
    echo "mt76x2e" >etc/modules.d/mt76x2e
    echo "mt7921e" >etc/modules.d/mt7921e
    echo "mt7915e" >etc/modules.d/mt7915e

    # GPU Driver
    echo "panfrost" >etc/modules.d/panfrost
    # PWM Driver
    echo "pwm_meson" >etc/modules.d/pwm_meson
    # Ath10k Driver
    echo "ath10k_core" >etc/modules.d/ath10k_core
    echo "ath10k_sdio" >etc/modules.d/ath10k_sdio
    echo "ath10k_usb" >etc/modules.d/ath10k_usb
    echo "ath10k_pci" >etc/modules.d/ath10k-pci
    echo "ath10k_core frame_mode=2" >etc/modules.d/ath10k
    # Enable watchdog driver
    echo "meson_gxbb_wdt" >etc/modules.d/watchdog
    # For rk3588
    echo "bifrost_kbase" >etc/modules.d/rk_gpu
    echo "rknpu" >etc/modules.d/rk_npu
    # For rk3568
    echo "rockchipdrm" >etc/modules.d/drm-rockchip
    echo "rk_crypto2" >etc/modules.d/rk_crypto
    echo -e "snd_soc_simple_card_utils\nsnd_soc_simple_card\nsnd_soc_rockchip_i2s" >etc/modules.d/snd-rk3568
    echo "pwm_fan" >etc/modules.d/pwm-fan
    echo "option" >etc/modules.d/usb-serial-option
    # For rk3328
    echo -e "snd_soc_simple_card_utils\nsnd_soc_simple_card\nsnd_soc_rockchip_i2s" >etc/modules.d/snd-rk3328

    # Add blacklist
    mkdir -p etc/modprobe.d
    cat >etc/modprobe.d/99-local.conf <<EOF
blacklist snd_soc_meson_aiu_i2s
alias brnf br_netfilter
alias pwm pwm_meson
alias wifi brcmfmac
EOF

    # Adjust startup settings
    [[ -f "etc/init.d/boot" ]] && {
        if ! grep -q 'ulimit -n' etc/init.d/boot; then
            sed -i '/kmodloader/i \\tulimit -n 51200\n' etc/init.d/boot
        fi
        if ! grep -q '/tmp/update' etc/init.d/boot; then
            sed -i '/mkdir -p \/tmp\/.uci/a \\tmkdir -p \/tmp\/update' etc/init.d/boot
        fi
    }
    [[ -f "etc/inittab" ]] && {
        sed -i 's/ttyAMA0/ttyAML0/' etc/inittab
        sed -i 's/ttyS0/tty0/' etc/inittab
    }

    # Automatic expansion of the third and fourth partitions on first boot
    echo "yes" >root/.todo_rootfs_resize

    # Relink the kmod binary and its symlinks
    [[ -x "sbin/kmod" ]] && (
        kmod_list="depmod insmod lsmod modinfo modprobe rmmod"
        for ki in ${kmod_list}; do
            rm -f sbin/${ki}
            ln -sf kmod sbin/${ki}
        done
    )

    # Add wireless master mode
    wireless_mac80211="lib/netifd/wireless/mac80211.sh"
    [[ -f "${wireless_mac80211}" ]] && {
        cp -f ${wireless_mac80211} ${wireless_mac80211}.bak
        sed -i "s|iw |ipconfig |g" ${wireless_mac80211}
    }

    # Generate random MAC address
    mac_hexchars="0123456789ABCDEF"
    mac_end=$(for i in {1..6}; do echo -n ${mac_hexchars:$((${RANDOM} % 16)):1}; done | sed -e 's/\(..\)/:\1/g')
    random_macaddr="9E:62${mac_end}"

    # Optimize wifi/bluetooth firmware configuration
    [[ -d "lib/firmware/brcm" ]] && (
        cd lib/firmware/brcm/ && rm -f ../*.hcd

        # gtking/gtking pro is bcm4356 wifi/bluetooth, wifi5 module AP6356S
        sed -e "s/macaddr=.*/macaddr=${random_macaddr}:00/" "brcmfmac4356-sdio.txt" >"brcmfmac4356-sdio.azw,gtking.txt"
        # gtking/gtking pro is bcm4356 wifi/bluetooth, wifi6 module AP6275S
        sed -e "s/macaddr=.*/macaddr=${random_macaddr}:01/" "brcmfmac4375-sdio.txt" >"brcmfmac4375-sdio.azw,gtking.txt"
        # MXQ Pro+ is AP6330(bcm4330) wifi/bluetooth
        sed -e "s/macaddr=.*/macaddr=${random_macaddr}:02/" "brcmfmac4330-sdio.txt" >"brcmfmac4330-sdio.crocon,mxq-pro-plus.txt"
        # HK1 Box & H96 Max X3 is bcm54339 wifi/bluetooth
        sed -e "s/macaddr=.*/macaddr=${random_macaddr}:03/" "brcmfmac4339-sdio.ZP.txt" >"brcmfmac4339-sdio.amlogic,sm1.txt"
        # new ugoos x3 is brm43456
        sed -e "s/macaddr=.*/macaddr=${random_macaddr}:04/" "brcmfmac43456-sdio.txt" >"brcmfmac43456-sdio.amlogic,sm1.txt"
        # x96max plus v5.1 (ip1001m phy) adopts am7256 (brcm4354)
        sed -e "s/macaddr=.*/macaddr=${random_macaddr}:05/" "brcmfmac4354-sdio.txt" >"brcmfmac4354-sdio.amlogic,sm1.txt"
        # panther x2 AP6212A
        sed -e "s/macaddr=.*/macaddr=${random_macaddr}:06/" "brcmfmac43430-sdio.txt" >"brcmfmac43430-sdio.panther,x2.txt"
        # ct2000 s922x is brm4359
        sed -i "s/macaddr=.*/macaddr=${random_macaddr}:07/" "brcmfmac4359-sdio.ali,ct2000.txt"
    )

    # Add firmware version information to the terminal banner
    [[ -n "${builder_name}" ]] && builder_display="Builder Name: ${builder_name} | " || builder_display=""
    [[ -f "etc/banner" ]] && {
        echo " Install OpenWrt: System → Amlogic Service → Install OpenWrt" >>etc/banner
        echo " Update  OpenWrt: System → Amlogic Service → Online  Update" >>etc/banner
        echo " Board: ${board} | OpenWrt Kernel: ${kernel_name}" >>etc/banner
        echo " ${builder_display}Production Date: $(date +%Y-%m-%d)" >>etc/banner
        echo "───────────────────────────────────────────────────────────────────────" >>etc/banner
    }

    # Add firmware information
    release_lines=(
        "PLATFORM='${PLATFORM}'"
        "MODEL_ID='${MODEL_ID}'"
        "MODEL_NAME='${MODEL_NAME}'"
        "SOC='${SOC}'"
        "FDTFILE='${FDTFILE}'"
        "FAMILY='${FAMILY}'"
        "BOARD='${board}'"
        "KERNEL_TAGS='${conf_kernel_tags}'"
        "KERNEL_VERSION='${kernel}'"
        "BOOT_CONF='${BOOT_CONF}'"
        "MAINLINE_UBOOT='${RECORD_MAINLINE_UBOOT}'"
        "ANDROID_UBOOT='${RECORD_BOOTLOADER_IMG}'"
        "OPENWRT_SOURCEREPO='${source_repo}'"
        "OPENWRT_SOURCECODE='${source_codename}'"
        "OPENWRT_SOURCEBRANCH='${source_branch}'"
        "BUILDER_NAME='${builder_name}'"
        "CONTRIBUTORS='${CONTRIBUTORS}'"
        "PACKAGED_DATE='$(date +%Y-%m-%d)'"
    )
    if [[ "${PLATFORM}" == "rockchip" ]]; then
        release_lines+=("TRUST_IMG='${RECORD_TRUST_IMG}'" "SHOW_INSTALL_MENU='no'")
    else
        release_lines+=("SHOW_INSTALL_MENU='yes'")
        [[ "${PLATFORM}" == "amlogic" ]] && release_lines+=("UBOOT_OVERLOAD='${UBOOT_OVERLOAD}'")
    fi
    printf '%s\n' "${release_lines[@]}" >>${op_release}
    # Creating a symbolic link alias
    ln -sf ${op_release#*/} ${ophub_release_file}

    # Remove menus that are not applicable to this device model
    install_menu=$(echo "${model_txt}" | awk -F'/' '{print $(NF-1)"/"$NF}')
    grep -E ":${FAMILY}:" ${install_menu} | cut -d':' -f1-8 >temp.txt && mv -f temp.txt ${install_menu}

    # Create initial /etc snapshot
    mkdir -p .snapshots
    btrfs subvolume snapshot -r etc .snapshots/etc-000 >/dev/null 2>&1

    sync && sleep 3
}

clean_tmp() {
    process_msg "(6/6) Cleaning temporary files."
    cd "${current_path}"

    # Unmount the OpenWrt image file
    fstrim "${tag_bootfs}" 2>/dev/null
    fstrim "${tag_rootfs}" 2>/dev/null
    umount -f "${tag_bootfs}" 2>/dev/null
    umount -f "${tag_rootfs}" 2>/dev/null
    losetup -d "${loop_new}" 2>/dev/null

    cd "${out_path}"
    # Compress the OpenWrt image file. Prefer pigz when available; otherwise fall back to gzip.
    if command -v pigz >/dev/null 2>&1; then
        pigz -qf "${openwrt_filename}"
    else
        gzip -qf "${openwrt_filename}"
    fi

    cd "${current_path}"
    # Clear temporary files directory
    rm -rf "${tmp_path}" && sync
}

loop_make() {
    cd "${current_path}"
    echo -e "${STEPS} Starting OpenWrt firmware build..."

    j="1"
    for b in "${make_openwrt[@]}"; do
        {
            # Set specific configuration for making OpenWrt system
            board="${b}"
            confirm_version

            i="1"
            for k in "${build_kernel[@]}"; do
                {
                    # Set the kernel version
                    kernel="${k}"

                    # Check disk space size.
                    echo -ne "(${j}.${i}) Making OpenWrt [\033[92m ${board} - ${conf_kernel_tags}/${kernel} \033[0m]. "
                    avail_kib="$(df -Pk "${make_path}" | awk 'NR==2 {print $4}')"
                    now_remaining_space=$((${avail_kib:-0} / 1024 / 1024))
                    if [[ "${now_remaining_space}" -le 3 ]]; then
                        echo -e "${WARNING} Remaining space is less than 3 GiB. Skipping this make."
                        break
                    else
                        echo "Remaining space: ${now_remaining_space} GiB."
                    fi

                    # Execute the following functions in sequence
                    make_image
                    extract_openwrt
                    replace_kernel
                    refactor_bootfs
                    refactor_rootfs
                    clean_tmp

                    echo -e "(${j}.${i}) OpenWrt built successfully. \n"
                    ((i++))
                }
            done

            ((j++))
        }
    done
}

# Show welcome message
echo -e "${STEPS} Welcome to the OpenWrt Image Builder!"
echo -e "${INFO} Build server environment: [ Release: ${host_release} / Host: ${arch_info} ] \n"
# Check script permission
[[ "$(id -u)" == 0 ]] || error_msg "please run this script as root: [ sudo ./${0} ]"

# Initialize variables and download the kernel
init_var "${@}"
check_data
# Find OpenWrt file
find_openwrt
# Download the dependency files
download_depends
# Query the latest kernel version
[[ "${auto_kernel}" =~ ^(true|yes)$ ]] && query_kernel
# Download the kernel files
download_kernel

# Show make settings
echo -e "${INFO} [ ${#make_openwrt[@]} ] target board(s) to build: [ $(echo ${make_openwrt[@]} | xargs) ]"
echo -e "${INFO} Kernel Repo: [ ${kernel_repo} ], Kernel Usage: [ ${kernel_usage} ] \n"
# Show server start information
echo -e "${INFO} Server disk usage before build: \n$(df -hT ${make_path}) \n"

# Loop to make OpenWrt firmware
loop_make

# Show server end information
echo -e "${STEPS} Server disk usage after build: \n$(df -hT ${make_path}) \n"
echo -e "${SUCCESS} All builds completed successfully."